com.wallstop-studios.dxmessaging 2.2.0 → 3.1.0

package/Editor/DxMessagingEditorInitializer.cs

@@ -1,6 +1,7 @@
 namespace DxMessaging.Editor
 {
 #if UNITY_EDITOR
+    using System;
     using Core;
     using Core.MessageBus;
     using Settings;
@@ -13,13 +14,30 @@ namespace DxMessaging.Editor
     [InitializeOnLoad]
     public static class DxMessagingEditorInitializer
     {
+        internal const string DomainReloadWarningMessage =
+            "[DxMessaging] Enter Play Mode Options are disabling domain reload. "
+            + "DxMessaging resets its internal statics, but third-party static state will persist. "
+            + "Audit integration code or re-enable domain reload if inconsistent behaviour occurs.";
+
         private static bool s_playModeWarningIssued;
+        private static bool s_ensureSettingsAssetScheduled;
+
+        internal static Action StaticStateResetter { get; set; } = DxMessagingStaticState.Reset;
+        internal static Func<DxMessagingSettings> PassiveSettingsLoader { get; set; } =
+            DxMessagingSettings.LoadSettingsPassive;
+        internal static Func<DxMessagingSettings> SettingsAssetEnsurer { get; set; } =
+            DxMessagingSettings.GetOrCreateSettings;
+        internal static Action<Action> AssetDatabaseMutationScheduler { get; set; } =
+            DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+        internal static Func<bool> DomainReloadDisabledDetector { get; set; } =
+            IsDomainReloadDisabled;
+        internal static Action<string> DomainReloadWarningLogger { get; set; } =
+            message => Debug.LogWarning(message);
 
         static DxMessagingEditorInitializer()
         {
             EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
             ApplyEditorSettings();
-            WarnIfDomainReloadDisabled();
         }
 
         private static void OnPlayModeStateChanged(PlayModeStateChange stateChange)
@@ -30,7 +48,6 @@ namespace DxMessaging.Editor
             )
             {
                 ApplyEditorSettings();
-                WarnIfDomainReloadDisabled();
             }
         }
 
@@ -45,34 +62,114 @@ namespace DxMessaging.Editor
             ApplyEditorSettings();
         }
 
-        private static void ApplyEditorSettings()
+        internal static void ApplyEditorSettings()
+        {
+            (StaticStateResetter ?? DxMessagingStaticState.Reset)();
+
+            // Issue #210: ApplyEditorSettings is reachable from the [InitializeOnLoad] static
+            // constructor during the domain-load asset-import window, where a synchronous
+            // AssetDatabase mutation -- the CreateAsset/SaveAssets/legacy-migration inside
+            // GetOrCreateSettings -- can re-enter the importer and hard-crash the native editor
+            // (GuidReservations::Reserve abort on Unity 6000.4+). Read current values via a
+            // mutation-free passive load now; ensure the asset exists/migrates on the next editor
+            // tick, off the import window.
+            Func<DxMessagingSettings> passiveSettingsLoader =
+                PassiveSettingsLoader ?? DxMessagingSettings.LoadSettingsPassive;
+            ApplySettingsAndDiagnostics(passiveSettingsLoader());
+            ScheduleEnsureSettingsAsset();
+        }
+
+        private static void ScheduleEnsureSettingsAsset()
+        {
+            // Debounce: ApplyEditorSettings runs from the cctor and on every play-mode transition,
+            // so coalesce to a single pending callback (mirrors the harvester's _rescanScheduled
+            // latch) instead of stacking redundant delayCall registrations.
+            if (s_ensureSettingsAssetScheduled)
+            {
+                return;
+            }
+            s_ensureSettingsAssetScheduled = true;
+            Action<Action> scheduler =
+                AssetDatabaseMutationScheduler
+                ?? DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+            scheduler(EnsureSettingsAssetThenApplyGlobals);
+        }
+
+        private static void EnsureSettingsAssetThenApplyGlobals()
         {
-            DxMessagingStaticState.Reset();
-            DxMessagingSettings settings = DxMessagingSettings.GetOrCreateSettings();
+            // Clear the latch BEFORE the work so a throw still leaves the next ApplyEditorSettings
+            // free to reschedule (self-healing). GetOrCreateSettings touches the AssetDatabase, so
+            // this callback must only be scheduled through DxMessagingEditorIdle's idle gate. Guard
+            // defensively rather than letting an exception escape this editor callback.
+            s_ensureSettingsAssetScheduled = false;
+            try
+            {
+                Func<DxMessagingSettings> settingsAssetEnsurer =
+                    SettingsAssetEnsurer ?? DxMessagingSettings.GetOrCreateSettings;
+                ApplySettingsAndDiagnostics(settingsAssetEnsurer());
+            }
+            catch (Exception ex)
+            {
+                DxMessagingEditorLog.LogWarning(
+                    "Deferred settings initialization failed; will retry on the next editor settings refresh.",
+                    ex
+                );
+            }
+        }
+
+        private static void ApplySettingsAndDiagnostics(DxMessagingSettings settings)
+        {
+            ApplyGlobals(settings);
+            WarnIfDomainReloadDisabled(settings);
+        }
+
+        private static void ApplyGlobals(DxMessagingSettings settings)
+        {
+            if (settings == null)
+            {
+                return;
+            }
             IMessageBus.GlobalDiagnosticsTargets = settings.DiagnosticsTargets;
             IMessageBus.GlobalMessageBufferSize = settings.MessageBufferSize;
         }
 
-        private static void WarnIfDomainReloadDisabled()
+        internal static void ResetTestSeams()
+        {
+            s_playModeWarningIssued = false;
+            s_ensureSettingsAssetScheduled = false;
+            StaticStateResetter = DxMessagingStaticState.Reset;
+            PassiveSettingsLoader = DxMessagingSettings.LoadSettingsPassive;
+            SettingsAssetEnsurer = DxMessagingSettings.GetOrCreateSettings;
+            AssetDatabaseMutationScheduler = DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+            DomainReloadDisabledDetector = IsDomainReloadDisabled;
+            DomainReloadWarningLogger = message => Debug.LogWarning(message);
+        }
+
+        private static void WarnIfDomainReloadDisabled(DxMessagingSettings settings)
         {
-            DxMessagingSettings settings = DxMessagingSettings.GetOrCreateSettings();
+            // Missing settings cannot be created from the domain-load passive path. The deferred
+            // ensure callback re-enters this method with the realized asset, so an initial null
+            // never permanently suppresses an explicitly unsuppressed settings asset.
             if (
                 s_playModeWarningIssued
+                || settings == null
                 || settings.SuppressDomainReloadWarning
-                || !EditorSettings.enterPlayModeOptionsEnabled
-                || (EditorSettings.enterPlayModeOptions & EnterPlayModeOptions.DisableDomainReload)
-                    == 0
+                || !(DomainReloadDisabledDetector ?? IsDomainReloadDisabled)()
             )
             {
                 return;
             }
 
             s_playModeWarningIssued = true;
-            Debug.LogWarning(
-                "[DxMessaging] Enter Play Mode Options are disabling domain reload. "
-                    + "DxMessaging resets its internal statics, but third-party static state will persist. "
-                    + "Audit integration code or re-enable domain reload if inconsistent behaviour occurs."
-            );
+            Action<string> warningLogger = DomainReloadWarningLogger ?? Debug.LogWarning;
+            warningLogger(DomainReloadWarningMessage);
+        }
+
+        private static bool IsDomainReloadDisabled()
+        {
+            return EditorSettings.enterPlayModeOptionsEnabled
+                && (EditorSettings.enterPlayModeOptions & EnterPlayModeOptions.DisableDomainReload)
+                    != 0;
         }
     }
 #endif

package/Editor/DxMessagingEditorInitializer.cs.meta

@@ -1,3 +1,11 @@
-fileFormatVersion: 2
-guid: b5eeb11bcc9d4d70861d5dc7084daae5
-timeCreated: 1749668189
+fileFormatVersion: 2
+guid: b5eeb11bcc9d4d70861d5dc7084daae5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/DxMessagingEditorLog.cs

@@ -0,0 +1,32 @@
+namespace DxMessaging.Editor
+{
+#if UNITY_EDITOR
+    using System;
+    using UnityEngine;
+
+    internal static class DxMessagingEditorLog
+    {
+        internal static void LogWarning(string message, Exception exception)
+        {
+            if (exception == null)
+            {
+                Debug.LogWarning($"[DxMessaging] {message}");
+                return;
+            }
+
+            Debug.LogWarning($"[DxMessaging] {message}{Environment.NewLine}{exception}");
+        }
+
+        internal static void LogError(string message, Exception exception)
+        {
+            if (exception == null)
+            {
+                Debug.LogError($"[DxMessaging] {message}");
+                return;
+            }
+
+            Debug.LogError($"[DxMessaging] {message}{Environment.NewLine}{exception}");
+        }
+    }
+#endif
+}

package/Editor/DxMessagingEditorLog.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7bfe4ed77fde4c05ab5bb314d8e7a4c0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/DxMessagingMenu.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: 517da34a8f694371b843ba34f89077d3
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 517da34a8f694371b843ba34f89077d3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/DxMessagingSceneBuildProcessor.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: ec8789213f7f4c30a9353e90fb4345c8
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: ec8789213f7f4c30a9353e90fb4345c8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Settings/DxMessagingBaseCallIgnoreSync.cs

@@ -0,0 +1,313 @@
+namespace DxMessaging.Editor.Settings
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Text;
+    using UnityEditor;
+    using UnityEngine;
+
+    /// <summary>
+    /// Synchronizes the <see cref="DxMessagingSettings._baseCallIgnoredTypes"/> list to a sidecar
+    /// text file shipped to the Roslyn analyzer via <c>csc.rsp</c>'s <c>-additionalfile</c> switch.
+    /// </summary>
+    /// <remarks>
+    /// The sidecar is a build-derived view: never hand-edited, always regenerated from the
+    /// ScriptableObject. The analyzer reads it because it cannot parse Unity-serialized YAML.
+    /// </remarks>
+    public static class DxMessagingBaseCallIgnoreSync
+    {
+        /// <summary>
+        /// Project-relative path to the auto-generated sidecar file. Other Editor scripts
+        /// (e.g., <see cref="SetupCscRsp"/>) reference this constant when wiring
+        /// <c>-additionalfile</c> entries.
+        /// </summary>
+        public const string SidecarAssetPath = "Assets/Editor/DxMessaging.BaseCallIgnore.txt";
+
+        private const string HeaderComment =
+            "# Auto-generated from Assets/Editor/DxMessagingSettings.asset; edit there instead.";
+        private const string FormatComment =
+            "# One fully-qualified type name per line. Lines starting with # are comments.";
+
+        /// <summary>
+        /// Test seam controlling WHEN deferred regeneration runs. Production schedules the work on
+        /// the next editor tick via <see cref="EditorApplication.delayCall"/>; tests substitute a
+        /// capturing scheduler so they can assert no synchronous AssetDatabase import happens and
+        /// then drive the deferred work deterministically without touching the filesystem.
+        /// </summary>
+        internal static Action<Action> DeferralScheduler { get; set; } =
+            work => EditorApplication.delayCall += () => work();
+
+        /// <summary>
+        /// Test seam for Unity editor state. Production uses Unity's update/compile flags; tests
+        /// substitute a deterministic busy/idle predicate to prove deferred work requeues.
+        /// </summary>
+        internal static Func<bool> CanMutateAssetDatabase { get; set; } =
+            DxMessaging.Editor.DxMessagingEditorIdle.CanMutateAssetDatabase;
+
+        /// <summary>
+        /// Test seam controlling WHAT regeneration does. Production performs the real
+        /// write + <see cref="AssetDatabase.ImportAsset"/> via <see cref="RegenerateSidecarCore"/>;
+        /// tests substitute a recorder so they can observe whether the apply happens synchronously
+        /// or only after the deferred tick, without writing the on-disk sidecar.
+        /// </summary>
+        internal static Action<DxMessagingSettings> SidecarApplier { get; set; } =
+            RegenerateSidecarCore;
+
+        /// <summary>
+        /// Test seam for the follow-up <c>csc.rsp</c> sync. Production schedules the
+        /// <c>-additionalfile</c> normalization after sidecar regeneration, which covers deferred
+        /// <c>OnValidate</c> writes that finish after <see cref="SetupCscRsp"/>'s startup pass.
+        /// </summary>
+        internal static Action CscRspAdditionalFileSyncScheduler { get; set; } =
+            ScheduleDefaultCscRspAdditionalFileSync;
+
+        /// <summary>
+        /// Regenerates the sidecar text file from the supplied settings asset. Writes only when
+        /// the on-disk content differs from what would be written, matching the
+        /// <c>FilesDiffer</c>-style policy used elsewhere in this Editor assembly to avoid
+        /// AssetDatabase churn during domain reload.
+        /// </summary>
+        /// <param name="settings">The settings asset. May be <c>null</c> -- no-op in that case.</param>
+        /// <remarks>
+        /// This is the entry point for explicit, user-driven edits (the "Ignore this type" button,
+        /// settings asset Inspector edits) and for EditMode tests: when Unity is idle the regen runs
+        /// synchronously for immediate feedback, and when Unity is mid-compile or mid-asset-import
+        /// it falls back to <see cref="RegenerateSidecarDeferred"/>. It MUST NOT be called from a
+        /// deserialization callback such as <c>ScriptableObject.OnValidate</c> -- those callbacks
+        /// can fire during the domain-load asset-import-worker window where
+        /// <see cref="EditorApplication.isUpdating"/> and <see cref="EditorApplication.isCompiling"/>
+        /// are both <c>false</c>, so this method would import synchronously and crash the editor
+        /// (issue #210). Use <see cref="RegenerateSidecarDeferred"/> from those callbacks instead.
+        /// </remarks>
+        public static void RegenerateSidecar(DxMessagingSettings settings)
+        {
+            if (settings == null)
+            {
+                return;
+            }
+
+            if (!CanCurrentlyMutateAssetDatabase())
+            {
+                RegenerateSidecarDeferred(settings);
+                return;
+            }
+
+            ApplySidecarAndScheduleCscRspSync(settings);
+        }
+
+        /// <summary>
+        /// Schedules sidecar regeneration for the next editor tick, NEVER writing or importing
+        /// synchronously. This is the only safe entry point from
+        /// <see cref="ScriptableObject.OnValidate"/> and other asset-deserialization callbacks.
+        /// </summary>
+        /// <param name="settings">The settings asset. May be <c>null</c> -- no-op in that case.</param>
+        /// <remarks>
+        /// A synchronous <see cref="AssetDatabase.ImportAsset"/> issued from within asset
+        /// deserialization re-enters the asset importer and hard-crashes the native editor
+        /// (<c>GuidReservations::Reserve</c> abort, issue #210, observed on Unity 6000.4+). The
+        /// dangerous window includes the domain-load asset-import worker, during which
+        /// <see cref="EditorApplication.isUpdating"/> and <see cref="EditorApplication.isCompiling"/>
+        /// are both <c>false</c> -- so the flag-based guard in <see cref="RegenerateSidecar"/> is
+        /// not sufficient on its own and this method defers unconditionally. The captured
+        /// <paramref name="settings"/> reference is safe to hold: <see cref="EditorApplication.delayCall"/>
+        /// is cleared on domain reload, so the callback never outlives its domain, and the
+        /// lifetime-aware null check covers the asset being destroyed (deleted) within the domain.
+        /// Scheduling here cannot throw, and the deferred regeneration self-guards via
+        /// <see cref="RegenerateSidecarCore"/>'s internal try/catch, so callers such as
+        /// <c>OnValidate</c> need no surrounding exception guard.
+        /// </remarks>
+        internal static void RegenerateSidecarDeferred(DxMessagingSettings settings)
+        {
+            if (settings == null)
+            {
+                return;
+            }
+
+            DxMessaging.Editor.DxMessagingEditorIdle.ScheduleAssetDatabaseMutation(
+                () =>
+                {
+                    if (settings == null)
+                    {
+                        return;
+                    }
+                    ApplySidecarAndScheduleCscRspSync(settings);
+                },
+                DeferralScheduler,
+                CanCurrentlyMutateAssetDatabase
+            );
+        }
+
+        private static bool CanCurrentlyMutateAssetDatabase()
+        {
+            Func<bool> canMutateAssetDatabase =
+                CanMutateAssetDatabase
+                ?? DxMessaging.Editor.DxMessagingEditorIdle.CanMutateAssetDatabase;
+            return canMutateAssetDatabase();
+        }
+
+        private static void ApplySidecarAndScheduleCscRspSync(DxMessagingSettings settings)
+        {
+            try
+            {
+                SidecarApplier(settings);
+            }
+            finally
+            {
+                ScheduleCscRspAdditionalFileSync();
+            }
+        }
+
+        private static void ScheduleCscRspAdditionalFileSync()
+        {
+            try
+            {
+                Action scheduler =
+                    CscRspAdditionalFileSyncScheduler ?? ScheduleDefaultCscRspAdditionalFileSync;
+                scheduler();
+            }
+            catch (Exception ex)
+            {
+                DxMessaging.Editor.DxMessagingEditorLog.LogWarning(
+                    "Failed to schedule csc.rsp base-call ignore additionalfile sync.",
+                    ex
+                );
+            }
+        }
+
+        private static void ScheduleDefaultCscRspAdditionalFileSync()
+        {
+            DxMessaging.Editor.SetupCscRsp.ScheduleAdditionalFileForIgnoreListSync();
+        }
+
+        private static void RegenerateSidecarCore(DxMessagingSettings settings)
+        {
+            if (settings == null)
+            {
+                return;
+            }
+
+            try
+            {
+                string newContent = BuildContent(settings._baseCallIgnoredTypes);
+                string absolutePath = GetAbsolutePath();
+                EnsureParentDirectoryExists(absolutePath);
+
+                if (File.Exists(absolutePath))
+                {
+                    string existing = File.ReadAllText(absolutePath);
+                    if (string.Equals(existing, newContent, StringComparison.Ordinal))
+                    {
+                        return;
+                    }
+                }
+
+                File.WriteAllText(absolutePath, newContent);
+                AssetDatabase.ImportAsset(SidecarAssetPath);
+            }
+            catch (Exception ex)
+            {
+                DxMessaging.Editor.DxMessagingEditorLog.LogWarning(
+                    $"Failed to write base-call ignore sidecar at '{SidecarAssetPath}'.",
+                    ex
+                );
+            }
+        }
+
+        /// <summary>
+        /// Reads the sidecar file and returns its non-comment, non-blank entries.
+        /// Tolerant of a missing file (returns an empty list) and of <c>#</c>-prefixed comment lines.
+        /// </summary>
+        public static IReadOnlyList<string> ReadSidecar()
+        {
+            try
+            {
+                string absolutePath = GetAbsolutePath();
+                if (!File.Exists(absolutePath))
+                {
+                    return Array.Empty<string>();
+                }
+
+                List<string> entries = new();
+                foreach (string rawLine in File.ReadAllLines(absolutePath))
+                {
+                    if (string.IsNullOrWhiteSpace(rawLine))
+                    {
+                        continue;
+                    }
+                    string trimmed = rawLine.Trim();
+                    if (trimmed.Length == 0 || trimmed[0] == '#')
+                    {
+                        continue;
+                    }
+                    entries.Add(trimmed);
+                }
+                return entries;
+            }
+            catch (Exception ex)
+            {
+                DxMessaging.Editor.DxMessagingEditorLog.LogWarning(
+                    $"Failed to read base-call ignore sidecar at '{SidecarAssetPath}'.",
+                    ex
+                );
+                return Array.Empty<string>();
+            }
+        }
+
+        internal static string BuildContent(IList<string> ignoredTypes)
+        {
+            StringBuilder builder = new();
+            builder.Append(HeaderComment).Append('\n');
+            builder.Append(FormatComment).Append('\n');
+
+            if (ignoredTypes == null)
+            {
+                return builder.ToString();
+            }
+
+            // Deterministic order for git-friendly diffs; deduplicate while preserving the user's
+            // typed casing where possible (Ordinal sort with Ordinal-set dedupe).
+            HashSet<string> seen = new(StringComparer.Ordinal);
+            List<string> sorted = new(ignoredTypes.Count);
+            foreach (string entry in ignoredTypes)
+            {
+                if (string.IsNullOrWhiteSpace(entry))
+                {
+                    continue;
+                }
+                string trimmed = entry.Trim();
+                if (seen.Add(trimmed))
+                {
+                    sorted.Add(trimmed);
+                }
+            }
+            sorted.Sort(StringComparer.Ordinal);
+
+            foreach (string entry in sorted)
+            {
+                builder.Append(entry).Append('\n');
+            }
+            return builder.ToString();
+        }
+
+        private static string GetAbsolutePath()
+        {
+            // Application.dataPath ends in "/Assets"; SidecarAssetPath begins with "Assets/".
+            string projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."))
+                .Replace("\\", "/");
+            return Path.Combine(projectRoot, SidecarAssetPath).Replace("\\", "/");
+        }
+
+        private static void EnsureParentDirectoryExists(string absolutePath)
+        {
+            string directory = Path.GetDirectoryName(absolutePath);
+            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+        }
+    }
+#endif
+}

package/Editor/Settings/DxMessagingBaseCallIgnoreSync.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 99dc9d314eff4388bba3679e20ca06c8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: