KnownMimeTypes.tt

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="Newtonsoft.Json" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Net" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Text.RegularExpressions" #>
<#@ import namespace="Newtonsoft.Json" #>
<#@ import namespace="Newtonsoft.Json.Linq" #>
<#@ output extension="cs" #>
using System;

namespace MimeMapping
{
<#
    const string APACHE_URL = "http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types";
    const string NGINX_URL = "https://raw.githubusercontent.com/h5bp/server-configs-nginx/master/mime.types";
	const string MIMEDB_URL = "https://raw.githubusercontent.com/jshttp/mime-db/master/src/custom-types.json";
#>
	///<summary>
	/// MIME type constants. Last updated on <#= DateTime.UtcNow.ToString("s") + "Z" #>. 
	/// Generated from the <a href="<#= APACHE_URL #>">apache</a> and <a href="<#= NGINX_URL #>">nginx</a> sources
	///</summary>
    public static class KnownMimeTypes
    {

<#
		Regex rgx = new Regex("[^a-zA-Z0-9]");

		string GetMimeFieldName(string mimeKey)
		{
			var result = rgx.Replace(mimeKey[0].ToString().ToUpperInvariant() + mimeKey.Substring(1), "");
			return char.IsDigit(result[0]) ? ("_" + result) : result;
		}

		string GetPageContent(string url)
		{
			using (var responseStream = WebRequest.CreateHttp(url).GetResponse().GetResponseStream())
			using (var streamReader = new StreamReader(responseStream, Encoding.UTF8))
			{
				return streamReader.ReadToEnd();				
			}
		}

		IEnumerable<string[]> GetMimeTypesFromText(string url, Func<string, string[]> processLine)
        {
            var content = GetPageContent(url);
			if (string.IsNullOrEmpty(content)) return Enumerable.Empty<string[]>();
            var lines = content.Split(new[] {'\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);
            return lines.Select(processLine).Where(newKeyPairs => newKeyPairs != null).ToList();
        }

		IEnumerable<string[]> GetMimeTypesFromJson(string url, Func<JObject, IEnumerable<string[]>> processObject)
        {
            var content = GetPageContent(url);
            if (string.IsNullOrEmpty(content)) return Enumerable.Empty<string[]>();
            var resource = JObject.Parse(content);
            return processObject(resource);
        }

        var entries = new List<string[]>();

		entries.AddRange(GetMimeTypesFromText(APACHE_URL, (line) => {
			if (line[0] == '#') return null;
			var parts = line.Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
			return parts.Length < 2 ? null : parts;
		}));

		entries.AddRange(GetMimeTypesFromText(NGINX_URL, (line) => {
			line = line.Trim().TrimEnd(';');
			if (line[0] == '#' || line[0] == '}' || line.StartsWith("types {")) return null;
			var parts = line.Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
			return parts.Length < 2 ? null : parts;
		}));

		entries.AddRange(GetMimeTypesFromJson(MIMEDB_URL, (resource) => {
			return from mimeTypes in resource.Children() 
			let mimeType = ((JProperty) mimeTypes).Name 
			from mimeTypeProperties in mimeTypes.Children() 
			from mimeTypeProperty in mimeTypeProperties.Children() 
			from mimeTypeValue in mimeTypeProperty.Values()
			where (mimeTypeProperty as JProperty)?.Name == "extensions"
			select new[]
			{
				mimeType,
				mimeTypeValue.Value<string>()
			};
		}));

		// build dictionary from entries, outputing found duplicates
		var _dict = new Dictionary<string, string>();
		var _reverseDict = new Dictionary<string, List<string>>();

		foreach (var parts in entries)
		{
			for (var i = 1; i < parts.Length; i++)
			{
				string existing;
				if (_dict.TryGetValue(parts[i], out existing))
				{
					if (existing != parts[0])
					{
#>
        // Dupe for <#= parts[i] #>: using <#= existing #> vs <#= parts[0] #> 
<#
					}
				}
				else
				{
					_dict[parts[i]] = parts[0];

					if (!_reverseDict.TryGetValue(parts[0], out var keyList))
					{
						keyList = new List<string>();
						_reverseDict.Add(parts[0], keyList);
					}

					keyList.Add(parts[i]);
				}
			}
		}

#>

		// Generated <#= _reverseDict.Count  #> unique mime type values
        // Generated <#= _dict.Count  #> type key pairs

<#
		// Output constants for each type
        foreach(var kp in _dict)
        {
#>
		///<summary><#= kp.Key #></summary>
        public const string <#= GetMimeFieldName(kp.Key) #> = "<#= kp.Value #>";
<#
		}
#>

		///<summary>File extensions</summary>
		public static class FileExtensions
		{
<#	
		// List constant field names
        foreach (var kp in _dict)
        {
#>
			///<summary><#= kp.Key #></summary>
			public const string <#= !Char.IsLetter(kp.Key[0]) ? "_" : string.Empty #><#= char.ToUpper(kp.Key[0]) + kp.Key.Substring(1).Replace('-', '_') #> = "<#= kp.Key #>";
<#
		}

#>
		}

        // List of all available extensions, used to build the dictionary
        internal static readonly Lazy<string[]> ALL_EXTS = new Lazy<string[]>(() => new [] {
<#
		// List constant field names
        foreach (var kp in _dict)
        {
#>
            FileExtensions.<#= !Char.IsLetter(kp.Key[0]) ? "_" : string.Empty #><#= char.ToUpper(kp.Key[0]) + kp.Key.Substring(1).Replace('-', '_') #>,
<#		
		}
#>
        });


        // Switch-case instead of dictionary since it does the hashing at compile time rather than run time
        internal static string LookupType(string type)
        {
            switch (type)
            {
<#
                // Output the actual literal C# dictionary
                foreach (var kp in _reverseDict)
                {
					foreach (var mimeKey in kp.Value)
					{					
#>
				case FileExtensions.<#= !Char.IsLetter(mimeKey[0]) ? "_" : string.Empty #><#= char.ToUpper(mimeKey[0]) + mimeKey.Substring(1).Replace('-', '_') #>:
<#
					}
#>
					return <#= GetMimeFieldName(kp.Value[0]) #>;

<#
                }
#>
				default: 
					return null;
            }
        }

        // Switch-case instead of dictionary since it does the hashing at compile time rather than run time
        internal static string[] LookupMimeType(string mimeType)
        {
            switch (mimeType)
            {
<#
                // Output the actual literal C# dictionary
                foreach (var kp in _reverseDict)
                {
					var first = true;
					foreach (var mimeKey in kp.Value)
					{
#>
				<#= first ? "" : "//" #>case <#= GetMimeFieldName(mimeKey) #>:
<#
						first = false;
					}
#>					return new[] {<#= string.Join(", ", kp.Value.Select(x => $"FileExtensions.{(!Char.IsLetter(x[0]) ? "_" : string.Empty)}{Char.ToUpper(x[0])}{x.Substring(1).Replace('-', '_')}")) #>};
<#
				}
#>
				default: 
					return null;
            }
		}
    }
}