Added file uri encoder

Author: sakno

src/DotNext.Tests/IO/FileUriTests.cs

@@ -0,0 +1,57 @@
+using System.Text.Encodings.Web;
+using DotNext.Buffers;
+
+namespace DotNext.IO;
+
+public sealed class FileUriTests : Test
+{
+    public static TheoryData<string, string> GetPaths()
+    {
+        var data = new TheoryData<string, string>();
+        if (OperatingSystem.IsWindows())
+        {
+            data.Add(@"C:\without\whitespace", @"C:\without\whitespace");
+            data.Add(@"C:\with whitespace", @"C:\with whitespace");
+            data.Add(@"C:\with\trailing\backslash", @"C:\with\trailing\backslash");
+            data.Add(@"C:\with\trailing\backslash and space", @"C:\with\trailing\backslash and space");
+            data.Add(@"C:\with\..\relative\.\components\", @"C:\relative\components\");
+            data.Add(@"C:\with\..\relative\.\components\", @"C:\relative\components\");
+            data.Add(@"C:\with\specials\chars\#\$\", @"C:\with\specials\chars\#\$\");
+            data.Add(@"C:\с\кириллицей", @"C:\с\кириллицей");
+            data.Add(@"\\unc\path", @"\\unc\path");
+            data.Add(@"\\?\dos\device", @"\\?\dos\device");
+            data.Add(@"\\.\dos\device", @"\\.\dos\device");
+        }
+        else
+        {
+            data.Add("/without/whitespace", "/without/whitespace");
+            data.Add("/with whitespace", "/with whitespace");
+            data.Add("/with/trailing/slash/", "/with/trailing/slash/");
+            data.Add("/with/trailing/slash and space/", "/with/trailing/slash and space/");
+            data.Add("/with/../relative/./components/", "/relative/components/");
+            data.Add("/with/special/chars/?/>/</", "/with/special/chars/?/>/</");
+            data.Add("/с/кириллицей", "/с/кириллицей");
+        }
+
+        return data;
+    }
+
+    [Theory]
+    [MemberData(nameof(GetPaths))]
+    public static void EncodeAsUri(string fileName, string expected)
+    {
+        var uri = FileUri.Encode(fileName);
+        Equal(expected, uri.LocalPath);
+    }
+
+    [Theory]
+    [MemberData(nameof(GetPaths))]
+    public static void EncodeAsUriChars(string fileName, string expected)
+    {
+        Span<char> buffer = stackalloc char[256];
+        True(FileUri.TryEncode(fileName, UrlEncoder.Default, buffer, out var charsWritten));
+
+        var uri = new Uri(buffer.Slice(0, charsWritten).ToString(), UriKind.Absolute);
+        Equal(expected, uri.LocalPath);
+    }
+}

src/DotNext/ExceptionMessages.cs

@@ -56,4 +56,6 @@ internal static string NoResult<TError>(TError errorCode)
     internal static string EndOfBuffer(long remaining) => string.Format(Resources.GetString("EndOfBuffer")!, remaining);
 
     internal static string OverlappedRange => Resources.GetString("OverlappedRange")!;
+
+    internal static string FullyQualifiedPathExpected => Resources.GetString("FullyQualifiedPathExpected")!;
 }

src/DotNext/ExceptionMessages.restext

@@ -19,4 +19,5 @@ KeyAlreadyExists=The key already exists
 ObjectMustNotBeArray=The object must not be represented by the array
 NoResult=The result of the operation is unavailable. Error code is {0}
 EndOfBuffer=The buffer has no data to read but the caller expects {0} extra elements
-OverlappedRange=The ranges are overlapped
+OverlappedRange=The ranges are overlapped
+FullyQualifiedPathExpected=The path must be fully-qualified

src/DotNext/IO/FileUri.cs

@@ -0,0 +1,90 @@
+using System.Buffers;
+using System.Diagnostics;
+using System.Text.Encodings.Web;
+using DotNext.Buffers;
+
+namespace DotNext.IO;
+
+/// <summary>
+/// Represents operations to work with <c>file://</c> scheme.
+/// </summary>
+public static class FileUri
+{
+    private const string FileScheme = "file://";
+
+    /// <summary>
+    /// Encodes file name as URI.
+    /// </summary>
+    /// <param name="fileName">The fully-qualified file name.</param>
+    /// <param name="settings">The encoding settings.</param>
+    /// <returns><paramref name="fileName"/> as <see cref="Uri"/>.</returns>
+    /// <exception cref="ArgumentException"><paramref name="fileName"/> is not fully-qualified.</exception>
+    public static Uri Encode(ReadOnlySpan<char> fileName, TextEncoderSettings? settings = null)
+    {
+        ThrowIfNotFullyQualified(fileName);
+        var encoder = settings is null ? UrlEncoder.Default : UrlEncoder.Create(settings);
+        var maxLength = FileScheme.Length + encoder.MaxOutputCharactersPerInputCharacter * fileName.Length;
+        using var buffer = (uint)maxLength <= (uint)SpanOwner<char>.StackallocThreshold
+            ? stackalloc char[maxLength]
+            : new SpanOwner<char>(maxLength);
+
+        TryEncodeCore(fileName, encoder, buffer.Span, out var writtenCount);
+        return new(buffer.Span.Slice(0, writtenCount).ToString(), UriKind.Absolute);
+    }
+
+    /// <summary>
+    /// Tries to encode file name as URI.
+    /// </summary>
+    /// <param name="fileName">The fully-qualified file name.</param>
+    /// <param name="encoder">The encoder that is used to encode the file name.</param>
+    /// <param name="output">The output buffer.</param>
+    /// <param name="charsWritten">The number of characters written to <paramref name="output"/>.</param>
+    /// <returns><see langword="true"/> if <paramref name="fileName"/> is encoded successfully; otherwise, <see langword="false"/>.</returns>
+    /// <exception cref="ArgumentException"><paramref name="fileName"/> is not fully-qualified.</exception>
+    public static bool TryEncode(ReadOnlySpan<char> fileName, UrlEncoder? encoder, Span<char> output, out int charsWritten)
+    {
+        ThrowIfNotFullyQualified(fileName);
+
+        return TryEncodeCore(fileName, encoder ?? UrlEncoder.Default, output, out charsWritten);
+    }
+
+    [StackTraceHidden]
+    private static void ThrowIfNotFullyQualified(ReadOnlySpan<char> fileName)
+    {
+        if (!Path.IsPathFullyQualified(fileName))
+            throw new ArgumentException(ExceptionMessages.FullyQualifiedPathExpected, nameof(fileName));
+    }
+
+    private static bool TryEncodeCore(ReadOnlySpan<char> fileName, UrlEncoder encoder, Span<char> output, out int charsWritten)
+    {
+        var result = false;
+        var writer = new SpanWriter<char>(output);
+        writer.Write(FileScheme);
+        while (!fileName.IsEmpty)
+        {
+            var index = fileName.IndexOf(Path.DirectorySeparatorChar);
+            ReadOnlySpan<char> component;
+            if (index >= 0)
+            {
+                component = fileName.Slice(0, index);
+                fileName = fileName.Slice(index + 1);
+            }
+            else
+            {
+                component = fileName;
+                fileName = default;
+            }
+
+            result = encoder.Encode(component, writer.RemainingSpan, out _, out charsWritten) is OperationStatus.Done;
+            if (!result)
+                break;
+
+            writer.Advance(charsWritten);
+            if (index >= 0)
+                writer.Add(Path.DirectorySeparatorChar);
+        }
+
+        charsWritten = writer.WrittenCount;
+        return result;
+    }
+}