feat: sync MIME metadata from IANA

Author: KSemenenko

.github/workflows/mime-sync.yml

@@ -26,7 +26,50 @@ jobs:
         run: dotnet restore
 
       - name: Run MIME sync tool
-        run: dotnet run --project ManagedCode.MimeTypes.Sync --configuration Release -- --prefer-remote
+        run: >
+          dotnet run --project ManagedCode.MimeTypes.Sync --configuration Release --
+          --prefer-remote
+          --template-concurrency 8
+
+      - name: Detect MIME database changes
+        id: mime_changes
+        shell: bash
+        run: |
+          if git diff --quiet -- ManagedCode.MimeTypes/mimeTypes.json ManagedCode.MimeTypes/mimeTypes.metadata.json; then
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+            echo "No MIME database changes detected." >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+            echo "MIME database changes detected." >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+      - name: Bump patch package version
+        if: steps.mime_changes.outputs.changed == 'true'
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          current_version="$(sed -nE 's#.*<Version>([^<]+)</Version>.*#\1#p' Directory.Build.props | head -n 1)"
+          package_version="$(sed -nE 's#.*<PackageVersion>([^<]+)</PackageVersion>.*#\1#p' Directory.Build.props | head -n 1)"
+
+          if [[ "$current_version" != "$package_version" ]]; then
+            echo "Version and PackageVersion differ: $current_version vs $package_version" >&2
+            exit 1
+          fi
+
+          if [[ ! "$current_version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "Unsupported version format: $current_version" >&2
+            exit 1
+          fi
+
+          IFS='.' read -r major minor patch <<< "$current_version"
+          next_version="$major.$minor.$((patch + 1))"
+          perl -0pi -e "s#<Version>\\Q$current_version\\E</Version>#<Version>$next_version</Version>#; s#<PackageVersion>\\Q$current_version\\E</PackageVersion>#<PackageVersion>$next_version</PackageVersion>#;" Directory.Build.props
+
+          echo "Bumped package version: $current_version -> $next_version" | tee -a "$GITHUB_STEP_SUMMARY"
+
+      - name: Test synced database
+        run: dotnet test --configuration Release --no-restore --verbosity normal
 
       - name: Create Pull Request
         uses: peter-evans/create-pull-request@v6
@@ -35,7 +78,11 @@ jobs:
           commit-message: "chore: sync MIME database"
           title: "chore: sync MIME database"
           body: |
-            Automated update of MIME database from configured sources.
+            Automated update of the MIME database from the IANA media types registry,
+            mime-db, Apache mime.types, and curated ManagedCode overrides.
+
+            When MIME data changes, this PR also bumps the package patch version.
+            See the workflow summary for the IANA registry date, source counts, and version bump.
           branch: chore/sync-mime-database
           delete-branch: true
           labels: |

Directory.Build.props

@@ -17,8 +17,8 @@
     <RepositoryUrl>https://github.com/managedcode/MimeTypes</RepositoryUrl>
     <PackageProjectUrl>https://github.com/managedcode/MimeTypes</PackageProjectUrl>
     <Product>Managed Code - MimeTypes</Product>
-    <Version>10.0.1</Version>
-    <PackageVersion>10.0.1</PackageVersion>
+    <Version>10.0.2</Version>
+    <PackageVersion>10.0.2</PackageVersion>
 
 </PropertyGroup>
 <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">

ManagedCode.MimeTypes.Generator/ManagedCode.MimeTypes.Generator.csproj

@@ -3,6 +3,7 @@
     <PropertyGroup>
         <LangVersion>14</LangVersion>
         <IsPackable>false</IsPackable>
+        <Nullable>enable</Nullable>
         <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
     </PropertyGroup>
 

ManagedCode.MimeTypes.Generator/MimeTypeSourceGenerator.cs

@@ -62,6 +62,7 @@ public void Execute(GeneratorExecutionContext context)
             using var document = JsonDocument.Parse(json);
 
             StringBuilder defineDictionaryBuilder = new();
+            StringBuilder metadataBuilder = new();
             StringBuilder propertyBuilder = new();
             Dictionary<string, string> types = new(StringComparer.OrdinalIgnoreCase);
 
@@ -79,6 +80,20 @@ public void Execute(GeneratorExecutionContext context)
                 types[ParseKey(extension)] = mimeValue;
             }
 
+            var metadataPath = GetMetadataPath(mimeTypesPath, context);
+            if (File.Exists(metadataPath))
+            {
+                using var metadataDocument = JsonDocument.Parse(File.ReadAllBytes(metadataPath));
+                foreach (var item in metadataDocument.RootElement.EnumerateObject())
+                {
+                    var initializer = BuildMimeTypeInfoInitializer(item.Name, item.Value);
+                    if (initializer.Length > 0)
+                    {
+                        metadataBuilder.AppendLine($"RegisterMimeTypeInfoInternal({initializer});");
+                    }
+                }
+            }
+
             foreach (var item in types)
             {
                 propertyBuilder.AppendLine($"public static string {item.Key} => \"{Escape(item.Value)}\";");
@@ -87,13 +102,17 @@ public void Execute(GeneratorExecutionContext context)
             context.ReportDiagnostic(Diagnostic.Create(MimeTypesLoadedDiagnostic, Location.None, types.Count));
 
             context.AddSource("MimeHelper.Properties.cs", SourceText.From(@$"
+using System;
+using System.Collections.Immutable;
+
 namespace ManagedCode.MimeTypes
 {{
 public static partial class MimeHelper
 {{
 static partial void Init()
 {{
 {defineDictionaryBuilder}
+{metadataBuilder}
 }}
 {propertyBuilder}
 }}
@@ -117,6 +136,13 @@ static partial void Init()
 
     private string GetMimeTypesPath(GeneratorExecutionContext context)
     {
+        var additionalFile = context.AdditionalFiles.FirstOrDefault(static file =>
+            string.Equals(Path.GetFileName(file.Path), "mimeTypes.json", StringComparison.OrdinalIgnoreCase));
+        if (additionalFile != null)
+        {
+            return additionalFile.Path;
+        }
+
         // Try to find mimeTypes.json in the project directory
         var compilation = context.Compilation;
         var projectDir = Path.GetDirectoryName(compilation.SyntaxTrees.First().FilePath);
@@ -136,6 +162,200 @@ private string GetMimeTypesPath(GeneratorExecutionContext context)
         return possiblePaths.FirstOrDefault(File.Exists) ?? possiblePaths[0];
     }
 
+    private string GetMetadataPath(string mimeTypesPath, GeneratorExecutionContext context)
+    {
+        var additionalFile = context.AdditionalFiles.FirstOrDefault(static file =>
+            string.Equals(Path.GetFileName(file.Path), "mimeTypes.metadata.json", StringComparison.OrdinalIgnoreCase));
+        if (additionalFile != null)
+        {
+            return additionalFile.Path;
+        }
+
+        var mimeTypesDirectory = Path.GetDirectoryName(mimeTypesPath);
+        var compilation = context.Compilation;
+        var projectDir = Path.GetDirectoryName(compilation.SyntaxTrees.First().FilePath);
+
+        var possiblePaths = new[]
+        {
+            Path.Combine(mimeTypesDirectory ?? "", "mimeTypes.metadata.json"),
+            Path.Combine(Directory.GetCurrentDirectory(), "mimeTypes.metadata.json"),
+            Path.Combine(projectDir ?? "", "mimeTypes.metadata.json"),
+            Path.Combine(Directory.GetParent(projectDir ?? "")?.FullName ?? "", "mimeTypes.metadata.json"),
+            Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "mimeTypes.metadata.json")
+        };
+
+        return possiblePaths.FirstOrDefault(File.Exists) ?? possiblePaths[0];
+    }
+
+    private static string BuildMimeTypeInfoInitializer(string fallbackMime, JsonElement element)
+    {
+        if (element.ValueKind != JsonValueKind.Object)
+        {
+            return string.Empty;
+        }
+
+        var mime = GetString(element, "mime") ?? fallbackMime;
+        if (string.IsNullOrWhiteSpace(mime))
+        {
+            return string.Empty;
+        }
+
+        var builder = new StringBuilder();
+        builder.AppendLine("new MimeTypeInfo");
+        builder.AppendLine("{");
+        builder.AppendLine($"Mime = {Literal(mime)},");
+        builder.AppendLine($"Extensions = {StringArray(GetStringArray(element, "extensions"))},");
+        builder.AppendLine($"IsIanaRegistered = {BoolLiteral(GetBool(element, "isIanaRegistered"))},");
+        builder.AppendLine($"IsObsolete = {BoolLiteral(GetBool(element, "isObsolete"))},");
+        AppendNullableString(builder, "PreferredMime", GetString(element, "preferredMime"));
+        AppendNullableString(builder, "Template", GetString(element, "template"));
+        AppendNullableString(builder, "TemplateUrl", GetString(element, "templateUrl"));
+        AppendNullableString(builder, "Source", GetString(element, "source"));
+        AppendNullableString(builder, "Registered", GetString(element, "registered"));
+        AppendNullableString(builder, "Updated", GetString(element, "updated"));
+        AppendNullableString(builder, "IntendedUsage", GetString(element, "intendedUsage"));
+        AppendNullableString(builder, "EncodingConsiderations", GetString(element, "encodingConsiderations"));
+        AppendNullableString(builder, "PublishedSpecification", GetString(element, "publishedSpecification"));
+        AppendNullableString(builder, "Applications", GetString(element, "applications"));
+        builder.AppendLine($"DeprecatedAliases = {StringArray(GetStringArray(element, "deprecatedAliases"))},");
+        builder.AppendLine($"References = {StringArray(GetStringArray(element, "references"))},");
+        builder.AppendLine($"MagicSignatures = {MagicSignatureArray(element)},");
+        builder.Append('}');
+        return builder.ToString();
+    }
+
+    private static void AppendNullableString(StringBuilder builder, string propertyName, string? value)
+    {
+        if (value == null)
+        {
+            return;
+        }
+
+        builder.AppendLine($"{propertyName} = {Literal(value)},");
+    }
+
+    private static string MagicSignatureArray(JsonElement element)
+    {
+        if (!element.TryGetProperty("magicSignatures", out var signatures) || signatures.ValueKind != JsonValueKind.Array)
+        {
+            return "Array.Empty<MimeMagicSignature>()";
+        }
+
+        var items = new List<string>();
+        foreach (var signature in signatures.EnumerateArray())
+        {
+            if (signature.ValueKind != JsonValueKind.Object)
+            {
+                continue;
+            }
+
+            var raw = GetString(signature, "raw");
+            if (string.IsNullOrWhiteSpace(raw))
+            {
+                continue;
+            }
+
+            var bytes = GetByteArray(signature, "bytes");
+            var hex = GetString(signature, "hex");
+            var offset = GetInt(signature, "offset");
+            items.Add($@"new MimeMagicSignature
+{{
+Raw = {Literal(raw)},
+Bytes = {ByteArray(bytes)},
+Hex = {Literal(hex)},
+Offset = {offset.ToString(System.Globalization.CultureInfo.InvariantCulture)}
+}}");
+        }
+
+        return items.Count == 0
+            ? "Array.Empty<MimeMagicSignature>()"
+            : "new[]\n{\n" + string.Join(",\n", items) + "\n}";
+    }
+
+    private static string StringArray(IReadOnlyList<string> values)
+    {
+        return values.Count == 0
+            ? "Array.Empty<string>()"
+            : "new[] { " + string.Join(", ", values.Select(Literal)) + " }";
+    }
+
+    private static string ByteArray(IReadOnlyList<byte> values)
+    {
+        return values.Count == 0
+            ? "ImmutableArray<byte>.Empty"
+            : "ImmutableArray.Create<byte>(" + string.Join(", ", values.Select(static value => $"0x{value:X2}")) + ")";
+    }
+
+    private static IReadOnlyList<string> GetStringArray(JsonElement element, string propertyName)
+    {
+        if (!element.TryGetProperty(propertyName, out var property) || property.ValueKind != JsonValueKind.Array)
+        {
+            return Array.Empty<string>();
+        }
+
+        var values = new List<string>();
+        foreach (var item in property.EnumerateArray())
+        {
+            if (item.ValueKind == JsonValueKind.String)
+            {
+                var value = item.GetString();
+                if (!string.IsNullOrWhiteSpace(value))
+                {
+                    values.Add(value);
+                }
+            }
+        }
+
+        return values;
+    }
+
+    private static IReadOnlyList<byte> GetByteArray(JsonElement element, string propertyName)
+    {
+        if (!element.TryGetProperty(propertyName, out var property) || property.ValueKind != JsonValueKind.Array)
+        {
+            return Array.Empty<byte>();
+        }
+
+        var values = new List<byte>();
+        foreach (var item in property.EnumerateArray())
+        {
+            if (item.ValueKind == JsonValueKind.Number && item.TryGetByte(out var value))
+            {
+                values.Add(value);
+            }
+        }
+
+        return values;
+    }
+
+    private static string? GetString(JsonElement element, string propertyName)
+    {
+        return element.TryGetProperty(propertyName, out var property) && property.ValueKind == JsonValueKind.String
+            ? property.GetString()
+            : null;
+    }
+
+    private static bool GetBool(JsonElement element, string propertyName)
+    {
+        return element.TryGetProperty(propertyName, out var property) &&
+            property.ValueKind is JsonValueKind.True or JsonValueKind.False &&
+            property.GetBoolean();
+    }
+
+    private static int GetInt(JsonElement element, string propertyName)
+    {
+        return element.TryGetProperty(propertyName, out var property) &&
+            property.ValueKind == JsonValueKind.Number &&
+            property.TryGetInt32(out var value)
+            ? value
+            : 0;
+    }
+
+    private static string BoolLiteral(bool value)
+    {
+        return value ? "true" : "false";
+    }
+
     private static string ParseKey(string key)
     {
         if (char.IsDigit(key[0]))
@@ -148,10 +368,17 @@ private static string ParseKey(string key)
         return key.ToUpperInvariant();
     }
 
+    private static string Literal(string? value)
+    {
+        return value == null ? "null" : $"\"{Escape(value)}\"";
+    }
+
     private static string Escape(string value)
     {
         return value
             .Replace("\\", "\\\\")
-            .Replace("\"", "\\\"");
+            .Replace("\"", "\\\"")
+            .Replace("\r", "\\r")
+            .Replace("\n", "\\n");
     }
 }

ManagedCode.MimeTypes.Sync/ManagedCode.MimeTypes.Sync.csproj

@@ -7,7 +7,4 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
-  <ItemGroup>
-    <PackageReference Include="System.Text.Json" Version="8.0.5" />
-  </ItemGroup>
 </Project>