Working on code and tests for a serve file extension to make developing a small web server easier.

Rest.Net.Tests/ServeFileTests.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FluentAssertions;
+using MontoyaTech.Rest.Net;
+using Xunit;
+
+namespace Rest.Net.Tests
+{
+    public class ServeFileTests
+    {
+        public string TestDirectory = null;
+
+        public string TestFile = null;
+
+        public ServeFileTests()
+        {
+            this.TestDirectory = Path.Combine(Environment.CurrentDirectory, "test/");
+
+            if (!Directory.Exists(this.TestDirectory))
+                Directory.CreateDirectory(this.TestDirectory);
+
+            this.TestFile = Path.Combine(this.TestDirectory, "test.html");
+
+            if (!File.Exists(this.TestFile))
+                File.WriteAllText(this.TestFile, "hello world");
+        }
+
+        [Fact]
+        public void ServeMultipleShouldWorkForFiles()
+        {
+            HttpListenerResponseExtensions.ResolveMultiPagePath(Path.Combine(Environment.CurrentDirectory, "test"), "../../test.html", null, out string resolvedPath, out bool isDirecotry).Should().BeTrue();
+
+            isDirecotry.Should().BeFalse();
+
+            resolvedPath.Should().BeEquivalentTo(this.TestFile);
+        }
+    }
+}

Rest.Net/HttpListenerResponseExtensions.cs

@@ -501,21 +501,129 @@ namespace MontoyaTech.Rest.Net
         /// <summary>
         /// Sets the response to serve a file in the context of a multi page application.
         /// </summary>
-        /// <param name="response"></param>
+        /// <param name="response">The response to modify</param>
-        /// <param name="request"></param>
+        /// <param name="basePath">The base path where to serve files from</param>
-        /// <returns></returns>
+        /// <param name="request">The request to serve</param>
-        public static HttpListenerResponse ServeMultiPage(this HttpListenerResponse response, HttpListenerRequest request)
+        /// <param name="indexFile">The name of the index file, default is index.html</param>
+        /// <returns>The modified response</returns>
+        public static HttpListenerResponse ServeMultiPage(this HttpListenerResponse response, string basePath, HttpListenerRequest request, string indexFile = "index.html")
         {
+            if (ResolveMultiPagePath(basePath, request.Url.LocalPath, indexFile, out string resolvedPath, out bool isDirectory))
+            {
+                if (isDirectory)
+                {
+                    return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                }
+                else
+                {
+                    if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
+                        return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                    else
+                        return response.WithStatus(HttpStatusCode.OK).WithFile(resolvedPath);
+                }
+            }
+            else
+            {
+                return response.WithStatus(HttpStatusCode.NotFound);
+            }
+        }
+
+        internal static bool ResolveMultiPagePath(string basePath, string requestPath, string indexFile, out string resolvedPath, out bool isDirectory)
+        {
+            resolvedPath = null;
+
+            isDirectory = false;
+
+            var relativePath = Path.GetRelativePath(basePath, requestPath);
+
+            if (string.IsNullOrWhiteSpace(relativePath) || relativePath == ".")
+                relativePath = indexFile;
+
+            var absolutePath = Path.Combine(basePath, relativePath);
+
+            if (File.Exists(absolutePath))
+            {
+                resolvedPath = absolutePath;
+
+                return true;
+            }
+            else if (Directory.Exists(absolutePath))
+            {
+                resolvedPath = absolutePath;
+
+                isDirectory = true;
+
+                return true;
+            }
+            else
+            {
+                return false;
+            }
         }
 
         /// <summary>
         /// Sets the response to serve a file in the context of a single page application.
         /// </summary>
-        /// <param name="response"></param>
+        /// <param name="response">The response to modify</param>
-        /// <param name="request"></param>
+        /// <param name="basePath">The base path where to serve files from</param>
-        /// <returns></returns>
+        /// <param name="request">The request to serve</param>
-        public static HttpListenerResponse ServeSinglePage(this HttpListenerResponse response, HttpListenerRequest request)
+        /// <param name="indexFile">The name of the index file, default is index.html</param>
+        /// <returns>The modified response</returns>
+        public static HttpListenerResponse ServeSinglePage(this HttpListenerResponse response, string basePath, HttpListenerRequest request, string indexFile = "index.html")
         {
+            var relativePath = Path.GetRelativePath(basePath, request.Url.LocalPath);
+
+            if (string.IsNullOrWhiteSpace(relativePath) || relativePath == ".")
+                relativePath = indexFile;
+
+            var absolutePath = Path.Combine(basePath, relativePath);
+
+            if (File.Exists(absolutePath))
+            {
+                if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
+                    return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                else
+                    return response.WithStatus(HttpStatusCode.OK).WithFile(absolutePath);
+            }
+            else if (Directory.Exists(absolutePath))
+            {
+                return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+            }
+            else
+            {
+                var components = relativePath.Split(new char[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList();
+
+                while (components.Count > 0)
+                {
+                    string path = Path.Combine(basePath, components[0]);
+
+                    if (File.Exists(path) || Directory.Exists(path))
+                        break;
+                    else
+                        components.RemoveAt(0);
+                }
+
+                if (components.Count == 0)
+                    return response.WithStatus(HttpStatusCode.NotFound);
+
+                var combined = Path.Combine(basePath, components.Separate(Path.PathSeparator));
+
+                if (File.Exists(combined))
+                {
+                    if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
+                        return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                    else
+                        return response.WithStatus(HttpStatusCode.OK).WithFile(absolutePath);
+                }
+                else if (Directory.Exists(combined))
+                {
+                    return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                }
+                else
+                {
+                    return response.WithStatus(HttpStatusCode.NotFound);
+                }
+            }
         }
     }
 }

Rest.Net/StringExtensions.cs

@@ -18,5 +18,39 @@ namespace MontoyaTech.Rest.Net
 
             return count;
         }
+
+        public static string Separate(this IList<string> input, char separator)
+        {
+            if (input == null || input.Count == 0)
+                return null;
+            else if (input.Count < 2)
+                return input[0];
+
+            var builder = new StringBuilder();
+
+            builder.Append(input[0]);
+
+            for (int i = 1; i < input.Count; i++)
+                builder.Append(separator).Append(input[1]);
+
+            return builder.ToString();
+        }
+
+        public static string Separate(this IList<string> input, string separator)
+        {
+            if (input == null || input.Count == 0)
+                return null;
+            else if (input.Count < 2)
+                return input[0];
+
+            var builder = new StringBuilder();
+
+            builder.Append(input[0]);
+
+            for (int i = 1; i < input.Count; i++)
+                builder.Append(separator).Append(input[1]);
+
+            return builder.ToString();
+        }
     }
 }