More robust JSON processing with tests and CI

.github/workflows/main.yml

@@ -0,0 +1,31 @@
+name: main
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  Build:
+    runs-on: windows-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        lfs: true
+
+    - name: Restore packages
+      run: nuget restore
+      working-directory: ./Source
+
+    - name: Setup build
+      uses: microsoft/setup-msbuild@v2
+
+    - name: Build targets
+      run: msbuild /t:ExplorerCommand /t:glTF /t:Tests /p:Configuration=Release /p:Platform=x64
+      working-directory: ./Source
+
+    - name: Run tests
+      run: dotnet test ./Build/Tests/bin/Release/AnyCPU/Tests.dll -s ./Source/.runsettings -v n

.gitignore

@@ -5,3 +5,6 @@ Build
 
 # published files end up here
 /Source/glTF/bin
+
+# launc settings
+/Source/glTF/Properties/launchSettings.json

Source/.runsettings

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RunSettings>
+  <RunConfiguration>
+    <ResultsDirectory>..\Build\Tests\Results</ResultsDirectory>
+  </RunConfiguration>
+</RunSettings>

Source/Core/Core.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <RootNamespace>glTF</RootNamespace>
+  </PropertyGroup>
+
+</Project>

Source/Core/Extensions/JsonExtensions.cs

@@ -0,0 +1,79 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace glTF
+{
+    internal static class JsonExtensions
+    {
+        public static JsonArray? GetArray(this JsonNode node, string propertyName, JsonArray? defaultValue = null)
+        {
+            var propertyNode = node[propertyName];
+            if (propertyNode == null || propertyNode.GetValueKind() != JsonValueKind.Array)
+            {
+                return defaultValue;
+            }
+
+            return propertyNode.AsArray();
+        }
+
+        public static int GetInt(this JsonNode node, string propertyName, int defaultValue = -1)
+        {
+            var propertyNode = node[propertyName];
+            if (propertyNode == null || propertyNode.GetValueKind() != JsonValueKind.Number)
+            {
+                return defaultValue;
+            }
+
+            return propertyNode.GetValue<int>();
+        }
+
+        public static string? GetString(this JsonNode node, string propertyName, string? defaultValue = null)
+        {
+            var propertyNode = node[propertyName];
+            if (propertyNode == null || propertyNode.GetValueKind() != JsonValueKind.String)
+            {
+                return defaultValue;
+            }
+
+            return propertyNode.GetValue<string>();
+        }
+
+        public static string? GetLocalPath(this JsonNode node, string propertyName, Uri baseUri, string? defaultValue = null)
+        {
+            var uriString = node.GetString(propertyName);
+            if (uriString == null)
+            {
+                return defaultValue;
+            }
+
+            if (!Uri.TryCreate(baseUri, uriString, out var uri) || !uri.IsFile)
+            {
+                return defaultValue;
+            }
+
+            return uri.LocalPath;
+        }
+
+        public static void SetInt(this JsonNode jsonNode, string propertyName, int value, int defaultValue)
+        {
+            if (value == defaultValue)
+            {
+                jsonNode.AsObject().Remove(propertyName);
+            }
+            else
+            {
+                jsonNode[propertyName] = JsonValue.Create(value);
+            }
+        }
+
+        public static bool Remove(this JsonNode node, string propertyName)
+        {
+            if (node.GetValueKind() != JsonValueKind.Object)
+            {
+                return false;
+            }
+
+            return node.AsObject().Remove(propertyName);
+        }
+    }
+}

Source/Core/MimeType.cs

@@ -0,0 +1,47 @@
+namespace glTF
+{
+    internal class MimeType
+    {
+        public static string ToFileExtension(string? mimeType)
+        {
+            switch (mimeType)
+            {
+                case "image/png":
+                    return ".png";
+                case "image/jpeg":
+                    return ".jpg";
+                case "image/vnd-ms.dds":
+                    return ".dds";
+                case "image/ktx2":
+                    return ".ktx2";
+                case "image/webp":
+                    return ".webp";
+            }
+
+            return ".bin";
+        }
+
+        public static string FromFileExtension(string? fileExtension)
+        {
+            if (fileExtension != null)
+            {
+                switch (fileExtension.ToLower())
+                {
+                    case ".png":
+                        return "image/png";
+                    case ".jpg":
+                    case ".jpeg":
+                        return "image/jpeg";
+                    case ".dds":
+                        return "image/vnd-ms.dds";
+                    case ".ktx2":
+                        return "image/ktx2";
+                    case ".webp":
+                        return "image/webp";
+                }
+            }
+
+            return "application/octet-stream";
+        }
+    }
+}