Working on the cookie container

Author: FlorianRappl

CHANGELOG.md

@@ -9,6 +9,7 @@ Released on Thursday, May 2 2019.
 - Added ability for binary data restore on assets (#19)
 - Added `DownloadAsync` extension method to `IUrlUtilities` elements
 - Added more extension methods to `IResponse` (e.g., `SaveToAsync`)
+- Introduced improved cookie container (#15)
 
 # 0.10.1
 

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

@@ -4,6 +4,7 @@
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>Key.snk</AssemblyOriginatorKeyFile>
     <IsPackable>false</IsPackable>
+    <LangVersion>7.1</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

src/AngleSharp.Io/AngleSharp.Io.csproj

@@ -6,6 +6,7 @@
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>Key.snk</AssemblyOriginatorKeyFile>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <LangVersion>7.1</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

src/AngleSharp.Io/Cookie/AdvancedCookieProvider.cs

@@ -0,0 +1,165 @@
+namespace AngleSharp.Io.Cookie
+{
+    using AngleSharp.Text;
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using static Helpers;
+    using static NetscapeCookieSerializer;
+
+    /// <summary>
+    /// Represents an advanced cookie provider that allows
+    /// persistence, snapshots, and more.
+    /// Stores the cookies in the Netscape compatible file
+    /// format.
+    /// </summary>
+    public class AdvancedCookieProvider : ICookieProvider
+    {
+        private readonly IFileHandler _handler;
+        private readonly Boolean _forceParse;
+        private readonly Boolean _httpOnlyExtension;
+        private readonly List<WebCookie> _cookies;
+
+        /// <summary>
+        /// Creates a new cookie provider with the given handler and options.
+        /// </summary>
+        /// <param name="handler">The handler responsible for file system interaction.</param>
+        /// <param name="options">The options to use for the cookie provider.</param>
+        public AdvancedCookieProvider(IFileHandler handler, AdvancedCookieProviderOptions options = default)
+        {
+            _handler = handler;
+            _forceParse = options.IsForceParse;
+            _httpOnlyExtension = options.IsHttpOnlyExtension;
+            _cookies = ReadCookies();
+        }
+
+        String ICookieProvider.GetCookie(Url url)
+        {
+            throw new NotImplementedException();
+        }
+
+        void ICookieProvider.SetCookie(Url url, String value)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Gets the available cookies.
+        /// </summary>
+        public IEnumerable<WebCookie> Cookies => _cookies.AsEnumerable();
+
+        /// <summary>
+        /// Gets the cookie with the given key.
+        /// </summary>
+        /// <param name="domain">The domain of the cookie.</param>
+        /// <param name="path">The path of the cookie.</param>
+        /// <param name="key">The key of the cookie.</param>
+        /// <returns>If matching cookie, if any.</returns>
+        public WebCookie FindCookie(String domain, String path, String key)
+        {
+            domain = CanonicalDomain(domain);
+            return _cookies.FirstOrDefault(cookie => cookie.Domain.Is(domain) && cookie.Path.Is(path) && cookie.Key.Is(key));
+        }
+
+        /// <summary>
+        /// Finds all cookies that match the given domain and optional path.
+        /// </summary>
+        /// <param name="domain">The domain to look for.</param>
+        /// <param name="path">The optional path of the cookie.</param>
+        /// <returns>The matching cookies.</returns>
+        public IEnumerable<WebCookie> FindCookies(String domain, String path = null)
+        {
+            domain = CanonicalDomain(domain);
+            var enumerable = _cookies.Where(cookie => cookie.Domain.Is(domain));
+
+            if (!String.IsNullOrEmpty(path))
+            {
+                enumerable = enumerable
+                    .Where(cookie => CheckPaths(path, cookie.Path));
+            }
+
+            return enumerable;
+        }
+
+        /// <summary>
+        /// Adds a new cookie to the collection.
+        /// </summary>
+        /// <param name="cookie">The cookie to add.</param>
+        public void AddCookie(WebCookie cookie)
+        {
+            _cookies.Remove(FindCookie(cookie.Domain, cookie.Path, cookie.Key));
+            _cookies.Add(cookie);
+            WriteCookies();
+        }
+
+        /// <summary>
+        /// Updates an existing cookie with a new cookie.
+        /// </summary>
+        /// <param name="oldCookie">The cookie to update.</param>
+        /// <param name="newCookie">The updated cookie content.</param>
+        public void UpdateCookie(WebCookie oldCookie, WebCookie newCookie)
+        {
+            _cookies.Remove(FindCookie(oldCookie.Domain, oldCookie.Path, oldCookie.Key));
+            AddCookie(newCookie);
+        }
+
+        /// <summary>
+        /// Removes a specific cookie matched by its domain, path, and key.
+        /// </summary>
+        /// <param name="domain">The domain to look for.</param>
+        /// <param name="path">The path to look for.</param>
+        /// <param name="key">The key of the cookie.</param>
+        /// <returns>The removed cookie if any.</returns>
+        public WebCookie RemoveCookie(String domain, String path, String key)
+        {
+            var cookie = FindCookie(domain, path, key);
+
+            if (cookie != null)
+            {
+                _cookies.Remove(cookie);
+                WriteCookies();
+            }
+
+            return cookie;
+        }
+
+        /// <summary>
+        /// Removes the cookies found for the provided domain and path.
+        /// </summary>
+        /// <param name="domain">The domain to look for.</param>
+        /// <param name="path">The optional path to match.</param>
+        /// <returns>The removed cookies.</returns>
+        public IEnumerable<WebCookie> RemoveCookies(String domain, String path = null)
+        {
+            var cookies = FindCookies(domain, path);
+
+            if (cookies.Any())
+            {
+                _cookies.RemoveAll(cookie => cookies.Contains(cookie));
+                WriteCookies();
+            }
+
+            return cookies;
+        }
+
+        /// <summary>
+        /// Removes all currently available cookies.
+        /// </summary>
+        /// <returns>The removed cookies.</returns>
+        public IEnumerable<WebCookie> RemoveAllCookies()
+        {
+            var cookies = _cookies.ToArray();
+            _cookies.RemoveAll(cookie => true);
+            return cookies;
+        }
+
+        private List<WebCookie> ReadCookies() => Deserialize(_handler.ReadFile(), _forceParse, _httpOnlyExtension);
+
+        private void WriteCookies()
+        {
+            var selection = _cookies.Where(m => m.IsPersistent);
+            var content = Serialize(selection, _httpOnlyExtension);
+            _handler.WriteFile(content);
+        }
+    }
+}

src/AngleSharp.Io/Cookie/AdvancedCookieProviderOptions.cs

@@ -0,0 +1,22 @@
+namespace AngleSharp.Io.Cookie
+{
+    using System;
+
+    /// <summary>
+    /// Options for the AdvancedCookieProvider.
+    /// </summary>
+    public struct AdvancedCookieProviderOptions
+    {
+        /// <summary>
+        /// Gets or sets if parsing is forced. If true, errors
+        /// will be suppressed.
+        /// </summary>
+        public Boolean IsForceParse { get; set; }
+
+        /// <summary>
+        /// Gets or sets if http only declarations should be
+        /// allowed.
+        /// </summary>
+        public Boolean IsHttpOnlyExtension { get; set; }
+    }
+}

src/AngleSharp.Io/Cookie/CookieParser.cs

@@ -0,0 +1,6 @@
+namespace AngleSharp.Io.Cookie
+{
+    internal class CookieParser
+    {
+    }
+}

src/AngleSharp.Io/Cookie/Helpers.cs

@@ -0,0 +1,102 @@
+namespace AngleSharp.Io.Cookie
+{
+    using AngleSharp.Text;
+    using System;
+    using System.Text.RegularExpressions;
+
+    internal static class Helpers
+    {
+        private static readonly DateTime EpochDate = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        private static readonly Regex NonAscii = new Regex("[^\\u0001-\\u007f]");
+        private static readonly String[] MonthsAbbr = new[]
+        {
+            "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+        };
+        private static readonly String[] DaysAbbr = new[]
+        {
+            "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+        };
+
+        public static Boolean CheckPaths(String requestPath, String cookiePath)
+        {
+            if (!cookiePath.Is(requestPath))
+            {
+                if (requestPath.StartsWith(cookiePath))
+                {
+                    if (cookiePath.EndsWith("/"))
+                    {
+                        return true;
+                    }
+                    else if (requestPath.Length > cookiePath.Length && requestPath[cookiePath.Length] == '/')
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            return true;
+        }
+
+        public static String CanonicalDomain(String str)
+        {
+            if (str != null)
+            {
+                // See: S4.1.2.3 & S5.2.3: ignore leading .
+                str = str.Trim().TrimStart('.');
+
+                if (NonAscii.IsMatch(str))
+                {
+                    str = Punycode.Encode(str);
+                }
+
+                return str.ToLowerInvariant();
+            }
+
+            return str;
+        }
+
+        public static String DecodeURIComponent(String component)
+        {
+            var content = component.UrlDecode();
+            return TextEncoding.Utf8.GetString(content);
+        }
+
+        public static String EncodeURIComponent(String component)
+        {
+            var content = TextEncoding.Utf8.GetBytes(component);
+            return content.UrlEncode();
+        }
+
+        public static Int32 ToEpoch(DateTime? current)
+        {
+            if (current.HasValue)
+            {
+                var time = current.Value.ToUniversalTime();
+                return (Int32)Math.Round(time.Subtract(EpochDate).TotalSeconds);
+            }
+
+            return 0;
+        }
+
+        public static DateTime? FromEpoch(Int32 seconds) => EpochDate.AddSeconds(seconds);
+
+        public static String FormatDate(DateTime date) => String.Concat(
+            DaysAbbr[(Int32)date.DayOfWeek],
+            ", ",
+            date.Day.ToString().PadLeft(2, '0'),
+            " ",
+            MonthsAbbr[date.Month],
+            " ",
+            date.Year.ToString(),
+            " ",
+            date.Hour.ToString().PadLeft(2, '0'),
+            ":",
+            date.Minute.ToString().PadLeft(2, '0'),
+            ":",
+            date.Second.ToString().PadLeft(2, '0'),
+            " GMT"
+        );
+    }
+}

src/AngleSharp.Io/Cookie/IFileHandler.cs

@@ -0,0 +1,22 @@
+namespace AngleSharp.Io.Cookie
+{
+    using System;
+
+    /// <summary>
+    /// Represents a file handler.
+    /// </summary>
+    public interface IFileHandler
+    {
+        /// <summary>
+        /// Reads the (text) content from the file.
+        /// </summary>
+        /// <returns>The content of the file.</returns>
+        String ReadFile();
+
+        /// <summary>
+        /// Writes the (text) content to the file.
+        /// </summary>
+        /// <param name="content">The content to write.</param>
+        void WriteFile(String content);
+    }
+}

src/AngleSharp.Io/Cookie/LocalFileHandler.cs

@@ -0,0 +1,28 @@
+namespace AngleSharp.Io.Cookie
+{
+    using System;
+    using System.IO;
+
+    /// <summary>
+    /// Represents a file handler against the local
+    /// file system.
+    /// </summary>
+    public class LocalFileHandler : IFileHandler
+    {
+        private readonly String _filePath;
+
+        /// <summary>
+        /// Creates a new local file handler for the given path.
+        /// </summary>
+        /// <param name="filePath">The path to resolve to.</param>
+        public LocalFileHandler(String filePath) => _filePath = filePath;
+
+        String IFileHandler.ReadFile() => File.ReadAllText(_filePath);
+
+        void IFileHandler.WriteFile(String content)
+        {
+            //TODO Replace with queued async method
+            File.WriteAllText(_filePath, content);
+        }
+    }
+}

src/AngleSharp.Io/Cookie/MemoryFileHandler.cs

@@ -0,0 +1,24 @@
+namespace AngleSharp.Io.Cookie
+{
+    using System;
+
+    /// <summary>
+    /// A memory file handler to feed the cookie provider.
+    /// Ideal for testing and sandboxed ("private") browsing.
+    /// </summary>
+    public class MemoryFileHandler : IFileHandler
+    {
+        private String _content;
+
+        /// <summary>
+        /// Creates a new memory file handler.
+        /// If no initial content is provided the handler starts empty.
+        /// </summary>
+        /// <param name="initialContent">The optional initial content.</param>
+        public MemoryFileHandler(String initialContent = "") => _content = initialContent;
+
+        String IFileHandler.ReadFile() => _content;
+
+        void IFileHandler.WriteFile(String content) => _content = content;
+    }
+}