Merged

Author: FlorianRappl

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 - Updated to latest version
 - Dispose WebSocket on unload
+- Added `about:` handler
 
 # 0.3.1
 

src/AngleSharp.Io.Tests/AngleSharp.Io.Tests.csproj

@@ -75,6 +75,7 @@
     <Compile Include="DisposableStream.cs" />
     <Compile Include="Helper.cs" />
     <Compile Include="Network\CookieHandlingTests.cs" />
+    <Compile Include="Network\AboutTests.cs" />
     <Compile Include="Network\FileRequesterTests.cs" />
     <Compile Include="Network\FtpRequesterTests.cs" />
     <Compile Include="Network\HttpClientRequesterTests.cs" />

src/AngleSharp.Io.Tests/Network/AboutTests.cs

@@ -0,0 +1,103 @@
+namespace AngleSharp.Io.Tests.Network
+{
+    using AngleSharp.Network;
+    using AngleSharp.Network.Default;
+    using Io.Network;
+    using NUnit.Framework;
+    using System.Collections.Generic;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    [TestFixture]
+    public class AboutTests
+    {
+        [Test]
+        public async Task InvokeAboutSettingsLowercaseShouldWorkFine()
+        {
+            var about = new AboutRequester();
+            var requests = new List<IRequest>();
+            var req = new Request
+            {
+                Address = Url.Create("about://settings"),
+                Method = HttpMethod.Get
+            };
+
+            about.SetRoute("settings", (request, cancel) =>
+            {
+                requests.Add(request);
+                return Task.FromResult(default(IResponse));
+            });
+
+            var response = await about.RequestAsync(req, CancellationToken.None);
+            Assert.IsNull(response);
+            Assert.AreEqual(1, requests.Count);
+        }
+
+        [Test]
+        public async Task InvokeAboutSettingsUppercaseShouldWorkFine()
+        {
+            var about = new AboutRequester();
+            var requests = new List<IRequest>();
+            var req = new Request
+            {
+                Address = Url.Create("about://Settings"),
+                Method = HttpMethod.Get
+            };
+
+            about.SetRoute("settings", (request, cancel) =>
+            {
+                requests.Add(request);
+                return Task.FromResult(default(IResponse));
+            });
+
+            var response = await about.RequestAsync(req, CancellationToken.None);
+            Assert.IsNull(response);
+            Assert.AreEqual(1, requests.Count);
+        }
+
+        [Test]
+        public async Task InvokeAboutUnsetUrlShouldNotFire()
+        {
+            var about = new AboutRequester();
+            var requests = new List<IRequest>();
+            var req = new Request
+            {
+                Address = Url.Create("about://bookmarks"),
+                Method = HttpMethod.Get
+            };
+
+            about.SetRoute("settings", (request, cancel) =>
+            {
+                requests.Add(request);
+                return Task.FromResult(default(IResponse));
+            });
+
+            var response = await about.RequestAsync(req, CancellationToken.None);
+            Assert.IsNull(response);
+            Assert.AreEqual(0, requests.Count);
+        }
+
+        [Test]
+        public async Task InvokeAboutUrlWithQueryShouldFire()
+        {
+            var about = new AboutRequester();
+            var requests = new List<IRequest>();
+            var req = new Request
+            {
+                Address = Url.Create("about://cache?device=memory"),
+                Method = HttpMethod.Get
+            };
+
+            about.SetRoute("cache", (request, cancel) =>
+            {
+                requests.Add(request);
+                return Task.FromResult(default(IResponse));
+            });
+
+            var response = await about.RequestAsync(req, CancellationToken.None);
+            Assert.IsNull(response);
+            Assert.AreEqual(1, requests.Count);
+            Assert.AreEqual(req.Address.Data, requests[0].Address.Data);
+        }
+    }
+}

src/AngleSharp.Io/AngleSharp.Io.csproj

@@ -52,6 +52,7 @@
     <Compile Include="Extensions\GeneralExtensions.cs" />
     <Compile Include="Dom\WebSocket.cs" />
     <Compile Include="Interfaces\IStorage.cs" />
+    <Compile Include="Network\AboutRequester.cs" />
     <Compile Include="Network\FileRequester.cs" />
     <Compile Include="Network\FtpRequester.cs" />
     <Compile Include="Network\HttpClientRequester.cs" />

src/AngleSharp.Io/IoConfigurationExtensions.cs

@@ -34,7 +34,14 @@ public static IConfiguration WithRequesters(this IConfiguration configuration, A
         public static IConfiguration WithRequesters(this IConfiguration configuration, HttpMessageHandler httpMessageHandler, Action<ConfigurationExtensions.LoaderSetup> setup = null)
         {
             var httpClient = new HttpClient(httpMessageHandler);
-            var requesters = new IRequester[] { new HttpClientRequester(httpClient), new DataRequester(), new FtpRequester(), new FileRequester() };
+            var requesters = new IRequester[] 
+            {
+                new HttpClientRequester(httpClient),
+                new DataRequester(),
+                new FtpRequester(),
+                new FileRequester(),
+                new AboutRequester()
+            };
             return configuration.WithDefaultLoader(setup, requesters);
         }
     }

src/AngleSharp.Io/Network/AboutRequester.cs

@@ -0,0 +1,91 @@
+namespace AngleSharp.Io.Network
+{
+    using AngleSharp.Network;
+    using System;
+    using System.Collections.Generic;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// Requester to perform about:// requests.
+    /// </summary>
+    public class AboutRequester : IRequester
+    {
+        private readonly Dictionary<String, Func<IRequest, CancellationToken, Task<IResponse>>> _routes;
+
+        /// <summary>
+        /// Creates a new about requester.
+        /// </summary>
+        public AboutRequester()
+        {
+            _routes = new Dictionary<String, Func<IRequest, CancellationToken, Task<IResponse>>>(StringComparer.InvariantCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// Sets the route for the given address.
+        /// </summary>
+        /// <param name="address">The address of the route.</param>
+        /// <param name="route">The route to use.</param>
+        public void SetRoute(String address, Func<IRequest, CancellationToken, Task<IResponse>> route)
+        {
+            _routes[address] = route;
+        }
+
+        /// <summary>
+        /// Gets the route for the given address, if any.
+        /// </summary>
+        /// <param name="address">The address of the route to obtain.</param>
+        /// <returns>The route, if any.</returns>
+        public Func<IRequest, CancellationToken, Task<IResponse>> GetRoute(String address)
+        {
+            var route = default(Func<IRequest, CancellationToken, Task<IResponse>>);
+            _routes.TryGetValue(address, out route);
+            return route;
+        }
+
+        /// <summary>
+        /// Performs an asynchronous request that can be cancelled.
+        /// </summary>
+        /// <param name="request">The options to consider.</param>
+        /// <param name="cancel">The token for cancelling the task.</param>
+        /// <returns>The task that will eventually give the response data.</returns>
+        public Task<IResponse> RequestAsync(IRequest request, CancellationToken cancel)
+        {
+            var address = GetAddress(request.Address.Data);
+            var route = GetRoute(address);
+
+            if (route != null)
+            {
+                return route.Invoke(request, cancel);
+            }
+
+            return Task.FromResult(default(IResponse));
+        }
+
+        /// <summary>
+        /// Checks if the given protocol is supported.
+        /// </summary>
+        /// <param name="protocol">The protocol to check for, e.g. file.</param>
+        /// <returns>True if the protocol is supported, otherwise false.</returns>
+        public Boolean SupportsProtocol(String protocol)
+        {
+            return protocol.Equals("about", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static String GetAddress(String data)
+        {
+            var skip = 0;
+
+            while (data.Length > skip && data[skip] == '/' && skip++ < 2) ;
+
+            var query = data.IndexOf('?');
+
+            if (query >= 0)
+            {
+                data = data.Remove(query);
+            }
+
+            return data.Remove(0, skip);
+        }
+    }
+}

src/AngleSharp.Io/Network/FileRequester.cs

@@ -45,7 +45,7 @@ public async Task<IResponse> RequestAsync(IRequest request, CancellationToken ca
         /// <returns>True if the protocol is supported, otherwise false.</returns>
         public Boolean SupportsProtocol(String protocol)
         {
-            return !String.IsNullOrEmpty(protocol) && protocol.Equals(ProtocolNames.File);
+            return protocol.Equals(ProtocolNames.File, StringComparison.OrdinalIgnoreCase);
         }
     }
 }

src/AngleSharp.Io/Network/FtpRequester.cs

@@ -48,7 +48,7 @@ public async Task<IResponse> RequestAsync(IRequest request, CancellationToken ca
         /// <returns>True if the protocol is supported, otherwise false.</returns>
         public Boolean SupportsProtocol(String protocol)
         {
-            return !String.IsNullOrEmpty(protocol) && protocol.Equals(ProtocolNames.Ftp);
+            return protocol.Equals(ProtocolNames.Ftp, StringComparison.OrdinalIgnoreCase);
         }
     }
 }