refactor: improve package exporter design and structure

Author: IShix-g

.github/workflows/reusable-build-package.yaml

@@ -35,7 +35,7 @@ on:
         description: 'Path where the builds should be stored.'
         required: false
         type: string
-        default: 'PackageExporter.Export'
+        default: 'PackageExporter.Editor.Builder.Build'
       custom-parameters:
         description: 'Custom parameters to configure the build. https://game.ci/docs/github/builder#customparameters'
         required: false

Assets/Editor/ArgumentsParser.cs

@@ -0,0 +1,15 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: adb346ada09d4f62892e782d664fc210, type: 3}
+  m_Name: PackageExporterSetting
+  m_EditorClassIdentifier: 
+  _folderPath: Assets/Plugins/PackageExporter/

Assets/Editor/PackageExporter.cs

@@ -0,0 +1,73 @@
+// https://github.com/game-ci/documentation/blob/main/example/BuildScript.cs
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace PackageExporter.Editor
+{
+    internal class ArgumentsParser
+    {
+        static readonly string s_eol = Environment.NewLine;
+        
+        public static Dictionary<string, string> GetValidatedOptions()
+        {
+            ParseCommandLineArguments(out var validatedOptions);
+            
+            if (!validatedOptions.TryGetValue("projectPath", out string _))
+            {
+                Console.WriteLine("Missing argument -projectPath");
+                EditorApplication.Exit(110);
+            }
+            if (!validatedOptions.TryGetValue("buildTarget", out string buildTarget))
+            {
+                Console.WriteLine("Missing argument -buildTarget");
+                EditorApplication.Exit(120);
+            }
+            if (!Enum.IsDefined(typeof(BuildTarget), buildTarget ?? string.Empty))
+            {
+                Console.WriteLine($"{buildTarget} is not a defined {nameof(BuildTarget)}");
+                EditorApplication.Exit(121);
+            }
+            if (!validatedOptions.TryGetValue("customBuildPath", out string _))
+            {
+                Console.WriteLine("Missing argument -customBuildPath");
+                EditorApplication.Exit(130);
+            }
+            if (!validatedOptions.TryGetValue("customBuildName", out string _))
+            {
+                Console.WriteLine("Missing argument -customBuildName");
+                EditorApplication.Exit(131);
+            }
+            return validatedOptions;
+        }
+
+        static void ParseCommandLineArguments(out Dictionary<string, string> providedArguments)
+        {
+            providedArguments = new Dictionary<string, string>();
+            var args = Environment.GetCommandLineArgs();
+
+            Console.WriteLine(
+                $"{s_eol}" +
+                $"###########################{s_eol}" +
+                $"#    Parsing settings     #{s_eol}" +
+                $"###########################{s_eol}" +
+                $"{s_eol}"
+            );
+            
+            for (int current = 0, next = 1; current < args.Length; current++, next++)
+            {
+                var isFlag = args[current].StartsWith("-");
+                if (!isFlag)
+                {
+                    continue;
+                }
+                var flag = args[current].TrimStart('-');
+                var flagHasValue = next < args.Length && !args[next].StartsWith("-");
+                var value = flagHasValue ? args[next].TrimStart('-') : "";
+                var displayValue = "\"" + value + "\"";
+                Console.WriteLine($"Found flag \"{flag}\" with value {displayValue}.");
+                providedArguments.Add(flag, value);
+            }
+        }
+    }
+}

Assets/Editor/PackageExporterSetting.asset

@@ -0,0 +1,83 @@
+
+using System.IO;
+using UnityEngine;
+using UnityEditor;
+
+namespace PackageExporter.Editor
+{
+    internal sealed class AssetDatabaseSupport
+    {
+        public static T CreateOrLoad<T>(string path) where T : ScriptableObject
+        {
+            var asset = LoadAsset<T>(path);
+            return asset != default
+                ? asset
+                : CreateAsset<T>(path);
+        }
+        
+        public static T CreateAsset<T>(string path) where T : ScriptableObject
+        {
+            CreateDirectories(path);
+            var asset = ScriptableObject.CreateInstance<T>();
+            AssetDatabase.CreateAsset(asset, path);
+            AssetDatabase.SaveAssets();
+            return asset;
+        }
+        
+        public static T LoadAsset<T>(string path) where T : ScriptableObject
+        {
+            var asset = AssetDatabase.LoadAssetAtPath<T>(path);
+            if (asset != default)
+            {
+                return asset;
+            }
+
+            var dir = Path.GetDirectoryName(path);
+            dir = dir?.Replace("\\", "/");
+            if (!AssetDatabase.IsValidFolder(dir))
+            {
+                return default;
+            }
+            var currentGuids = AssetDatabase.FindAssets("t:" + typeof(T), new[] { dir });
+            if (currentGuids is {Length: > 0})
+            {
+                path = AssetDatabase.GUIDToAssetPath(currentGuids[0]);
+                asset = AssetDatabase.LoadAssetAtPath<T>(path);
+            }
+            return asset;
+        }
+
+        public static void CreateDirectories(string path)
+        {
+            if (!path.StartsWith("Assets"))
+            {
+                Debug.LogError("The path must start with 'Assets' ");
+                return;
+            }
+
+            path = Path.HasExtension(path)
+                ? Path.GetDirectoryName(path)
+                : path;
+            path = path?.Replace("\\", "/");
+
+            if (string.IsNullOrEmpty(path)
+                || AssetDatabase.IsValidFolder(path))
+            {
+                return;
+            }
+    
+            var folders = path.Split('/');
+            var parentFolder = folders[0];
+    
+            for (var i = 1; i < folders.Length; i++)
+            {
+                var newFolder = parentFolder + "/" + folders[i];
+                if (!AssetDatabase.IsValidFolder(newFolder))
+                {
+                    AssetDatabase.CreateFolder(parentFolder, folders[i]);
+                }
+                parentFolder = newFolder;
+            }
+        }
+    }
+}