com.wallstop-studios.dxmessaging 2.0.0-rc11 → 2.0.0-rc13

package/Runtime/Unity/MessagingComponent.cs

@@ -1,99 +1,99 @@
-namespace DxMessaging.Unity
-{
-    using System;
-    using System.Collections.Generic;
-    using Core;
-    using UnityEngine;
-    using UnityEngine.Serialization;
-
-    [DisallowMultipleComponent]
-    public sealed class MessagingComponent : MonoBehaviour
-    {
-        [FormerlySerializedAs("_emitMessagesWhenDisabled")]
-        public bool emitMessagesWhenDisabled;
-
-        private MessageHandler _messageHandler;
-
-        private readonly Dictionary<MonoBehaviour, MessageRegistrationToken> _registeredListeners =
-            new();
-
-        public MessageRegistrationToken Create(MonoBehaviour listener)
-        {
-            if (listener == null)
-            {
-                throw new ArgumentNullException(nameof(listener));
-            }
-
-            if (gameObject.GetInstanceID() != listener.gameObject.GetInstanceID())
-            {
-                throw new ArgumentException(
-                    $"Cannot create a RegistrationToken without an valid owner. {listener.gameObject.GetInstanceID()}."
-                );
-            }
-
-            if (
-                _registeredListeners.TryGetValue(
-                    listener,
-                    out MessageRegistrationToken createdToken
-                )
-            )
-            {
-                MessagingDebug.Log(
-                    LogLevel.Warn,
-                    "Ignoring double RegistrationToken request for {0}.",
-                    listener
-                );
-                return createdToken;
-            }
-
-            if (_messageHandler == null)
-            {
-                _messageHandler = new MessageHandler(gameObject) { active = true };
-                MessagingDebug.Log(
-                    LogLevel.Debug,
-                    "Creating MessageHandler for componentType {0}, GameObject name: {1}, InstanceId: {2}.",
-                    listener.GetType(),
-                    listener.gameObject.name,
-                    (InstanceId)gameObject
-                );
-            }
-            else
-            {
-                MessagingDebug.Log(
-                    LogLevel.Debug,
-                    "Using existing MessageHandler for componentType {0}, GameObject name: {1}, InstanceId: {2}.",
-                    listener.GetType(),
-                    listener.gameObject.name,
-                    (InstanceId)gameObject
-                );
-            }
-
-            createdToken = MessageRegistrationToken.Create(_messageHandler);
-            _registeredListeners[listener] = createdToken;
-            return createdToken;
-        }
-
-        public void OnEnable()
-        {
-            ToggleMessageHandler(true);
-        }
-
-        public void OnDisable()
-        {
-            ToggleMessageHandler(false);
-        }
-
-        public void ToggleMessageHandler(bool newActive)
-        {
-            if (!newActive && emitMessagesWhenDisabled)
-            {
-                return;
-            }
-
-            if (_messageHandler != null && _messageHandler.active != newActive)
-            {
-                _messageHandler.active = newActive;
-            }
-        }
-    }
-}
+namespace DxMessaging.Unity
+{
+    using System;
+    using System.Collections.Generic;
+    using Core;
+    using UnityEngine;
+    using UnityEngine.Serialization;
+
+    [DisallowMultipleComponent]
+    public sealed class MessagingComponent : MonoBehaviour
+    {
+        [FormerlySerializedAs("_emitMessagesWhenDisabled")]
+        public bool emitMessagesWhenDisabled;
+
+        private MessageHandler _messageHandler;
+
+        private readonly Dictionary<MonoBehaviour, MessageRegistrationToken> _registeredListeners =
+            new();
+
+        public MessageRegistrationToken Create(MonoBehaviour listener)
+        {
+            if (listener == null)
+            {
+                throw new ArgumentNullException(nameof(listener));
+            }
+
+            if (gameObject.GetInstanceID() != listener.gameObject.GetInstanceID())
+            {
+                throw new ArgumentException(
+                    $"Cannot create a RegistrationToken without an valid owner. {listener.gameObject.GetInstanceID()}."
+                );
+            }
+
+            if (
+                _registeredListeners.TryGetValue(
+                    listener,
+                    out MessageRegistrationToken createdToken
+                )
+            )
+            {
+                MessagingDebug.Log(
+                    LogLevel.Warn,
+                    "Ignoring double RegistrationToken request for {0}.",
+                    listener
+                );
+                return createdToken;
+            }
+
+            if (_messageHandler == null)
+            {
+                _messageHandler = new MessageHandler(gameObject) { active = true };
+                MessagingDebug.Log(
+                    LogLevel.Debug,
+                    "Creating MessageHandler for componentType {0}, GameObject name: {1}, InstanceId: {2}.",
+                    listener.GetType(),
+                    listener.gameObject.name,
+                    (InstanceId)gameObject
+                );
+            }
+            else
+            {
+                MessagingDebug.Log(
+                    LogLevel.Debug,
+                    "Using existing MessageHandler for componentType {0}, GameObject name: {1}, InstanceId: {2}.",
+                    listener.GetType(),
+                    listener.gameObject.name,
+                    (InstanceId)gameObject
+                );
+            }
+
+            createdToken = MessageRegistrationToken.Create(_messageHandler);
+            _registeredListeners[listener] = createdToken;
+            return createdToken;
+        }
+
+        public void OnEnable()
+        {
+            ToggleMessageHandler(true);
+        }
+
+        public void OnDisable()
+        {
+            ToggleMessageHandler(false);
+        }
+
+        public void ToggleMessageHandler(bool newActive)
+        {
+            if (!newActive && emitMessagesWhenDisabled)
+            {
+                return;
+            }
+
+            if (_messageHandler != null && _messageHandler.active != newActive)
+            {
+                _messageHandler.active = newActive;
+            }
+        }
+    }
+}

package/Runtime/Unity/MessagingComponent.cs.meta

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

package/Runtime/Unity.meta

@@ -1,8 +1,8 @@
-fileFormatVersion: 2
-guid: 702cd276d59d0b1458d22d6d33e91c6e
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 702cd276d59d0b1458d22d6d33e91c6e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/WallstopStudios.DxMessaging.asmdef

@@ -1,16 +1,16 @@
-{
-    "name": "WallstopStudios.DxMessaging",
-    "rootNamespace": "DxMessaging",
-    "references": [],
-    "includePlatforms": [],
-    "excludePlatforms": [],
-    "allowUnsafeCode": false,
-    "overrideReferences": false,
-    "precompiledReferences": [
-        "System.Runtime.CompilerServices.Unsafe.dll"
-    ],
-    "autoReferenced": true,
-    "defineConstraints": [],
-    "versionDefines": [],
-    "noEngineReferences": false
+{
+    "name": "WallstopStudios.DxMessaging",
+    "rootNamespace": "DxMessaging",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [
+        "System.Runtime.CompilerServices.Unsafe.dll"
+    ],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
 }

package/Runtime.meta

@@ -1,8 +1,8 @@
-fileFormatVersion: 2
-guid: 6f74abcfd99785a4c857762e91493ea3
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 6f74abcfd99785a4c857762e91493ea3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxAutoMessageTypeGenerator.cs

@@ -1,75 +1,92 @@
-namespace WallstopStudios.DxMessaging.SourceGenerators;
-
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
-
-[Generator]
-public sealed class DxAutoMessageTypeGenerator : ISourceGenerator
-{
-    public void Initialize(GeneratorInitializationContext context)
-    {
-        context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
-    }
-
-    public void Execute(GeneratorExecutionContext context)
-    {
-        if (context.SyntaxReceiver is not SyntaxReceiver receiver)
-        {
-            return;
-        }
-
-        INamedTypeSymbol attributeSymbol = context.Compilation.GetTypeByMetadataName("DxMessaging.Core.Attributes.DxAutoMessageTypeAttribute");
-
-        foreach (TypeDeclarationSyntax classDeclaration in receiver.CandidateClasses)
-        {
-            SemanticModel model = context.Compilation.GetSemanticModel(classDeclaration.SyntaxTree);
-            ISymbol classSymbol = ModelExtensions.GetDeclaredSymbol(model, classDeclaration);
-
-            if (classSymbol.GetAttributes().Any(
-                    attributeData => attributeData.AttributeClass.Equals(
-                        attributeSymbol, SymbolEqualityComparer.Default)))
-            {
-                string namespaceName = classSymbol.ContainingNamespace.ToDisplayString();
-                string className = classSymbol.Name;
-                string typeKind = classDeclaration.Kind() == SyntaxKind.ClassDeclaration ? "class" : "struct";
-
-                string source = $$"""
-
-                                  namespace {{namespaceName}}
-                                  {
-                                      public partial {{typeKind}} {{className}}
-                                      {
-                                          public System.Type MessageType => typeof({{className}});
-                                      }
-                                  }
-
-                                  """;
-
-                context.AddSource($"{className}_DxAutoMessageType.g.cs", SourceText.From(source, Encoding.UTF8));
-            }
-        }
-    }
-
-    private sealed class SyntaxReceiver : ISyntaxReceiver
-    {
-        public List<TypeDeclarationSyntax> CandidateClasses { get; } = [];
-
-        public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
-        {
-            if (syntaxNode is TypeDeclarationSyntax typeDeclarationSyntax)
-            {
-                if (typeDeclarationSyntax.AttributeLists.Count > 0 &&
-                    (typeDeclarationSyntax.Kind() == SyntaxKind.ClassDeclaration ||
-                     typeDeclarationSyntax.Kind() == SyntaxKind.StructDeclaration))
-                {
-                    CandidateClasses.Add(typeDeclarationSyntax);
-                }
-            }
-        }
-    }
-}
+namespace WallstopStudios.DxMessaging.SourceGenerators;
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+[Generator]
+public sealed class DxAutoMessageTypeGenerator : ISourceGenerator
+{
+    public void Initialize(GeneratorInitializationContext context)
+    {
+        context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
+    }
+
+    public void Execute(GeneratorExecutionContext context)
+    {
+        if (context.SyntaxReceiver is not SyntaxReceiver receiver)
+        {
+            return;
+        }
+
+        INamedTypeSymbol attributeSymbol = context.Compilation.GetTypeByMetadataName(
+            "DxMessaging.Core.Attributes.DxAutoMessageTypeAttribute"
+        );
+
+        foreach (TypeDeclarationSyntax classDeclaration in receiver.CandidateClasses)
+        {
+            SemanticModel model = context.Compilation.GetSemanticModel(classDeclaration.SyntaxTree);
+            ISymbol classSymbol = ModelExtensions.GetDeclaredSymbol(model, classDeclaration);
+
+            if (
+                classSymbol
+                    .GetAttributes()
+                    .Any(attributeData =>
+                        attributeData.AttributeClass.Equals(
+                            attributeSymbol,
+                            SymbolEqualityComparer.Default
+                        )
+                    )
+            )
+            {
+                string namespaceName = classSymbol.ContainingNamespace.ToDisplayString();
+                string className = classSymbol.Name;
+                string typeKind =
+                    classDeclaration.Kind() == SyntaxKind.ClassDeclaration ? "class" : "struct";
+
+                string source = $$"""
+
+                    namespace {{namespaceName}}
+                    {
+                        public partial {{typeKind}} {{className}}
+                        {
+                            public System.Type MessageType => typeof({{className}});
+                        }
+                    }
+                    
+                    """;
+
+                context.AddSource(
+                    $"{className}_DxAutoMessageType.g.cs",
+                    SourceText.From(source, Encoding.UTF8)
+                );
+            }
+        }
+    }
+
+    private sealed class SyntaxReceiver : ISyntaxReceiver
+    {
+        public List<TypeDeclarationSyntax> CandidateClasses { get; } = [];
+
+        public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
+        {
+            if (syntaxNode is TypeDeclarationSyntax typeDeclarationSyntax)
+            {
+                if (
+                    typeDeclarationSyntax.AttributeLists.Count > 0
+                    && (
+                        typeDeclarationSyntax.Kind() == SyntaxKind.ClassDeclaration
+                        || typeDeclarationSyntax.Kind() == SyntaxKind.StructDeclaration
+                    )
+                )
+                {
+                    CandidateClasses.Add(typeDeclarationSyntax);
+                }
+            }
+        }
+    }
+}

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxAutoMessageTypeGenerator.cs.meta

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

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxBroadcastMessageGenerator.cs

@@ -1,77 +1,94 @@
-namespace WallstopStudios.DxMessaging.SourceGenerators;
-
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
-
-[Generator]
-public sealed class DxBroadcastMessageGenerator : ISourceGenerator
-{
-    public void Initialize(GeneratorInitializationContext context)
-    {
-        context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
-    }
-
-    public void Execute(GeneratorExecutionContext context)
-    {
-        if (context.SyntaxReceiver is not SyntaxReceiver receiver)
-        {
-            return;
-        }
-
-        INamedTypeSymbol attributeSymbol = context.Compilation.GetTypeByMetadataName("DxMessaging.Core.Attributes.DxBroadcastMessageAttribute");
-
-        foreach (TypeDeclarationSyntax classDeclaration in receiver.CandidateClasses)
-        {
-            SemanticModel model = context.Compilation.GetSemanticModel(classDeclaration.SyntaxTree);
-            ISymbol classSymbol = ModelExtensions.GetDeclaredSymbol(model, classDeclaration);
-
-            if (classSymbol.GetAttributes().Any(
-                    attributeData => attributeData.AttributeClass.Equals(
-                        attributeSymbol, SymbolEqualityComparer.Default)))
-            {
-                string namespaceName = classSymbol.ContainingNamespace.ToDisplayString();
-                string className = classSymbol.Name;
-                string typeKind = classDeclaration.Kind() == SyntaxKind.ClassDeclaration ? "class" : "struct";
-
-                string source = $$"""
-
-                                  namespace {{namespaceName}}
-                                  {
-                                      using DxMessaging.Core.Messages;
-                                  
-                                      public partial {{typeKind}} {{className}} : IBroadcastMessage
-                                      {
-                                          public System.Type MessageType => typeof({{className}});
-                                      }
-                                  }
-
-                                  """;
-
-                context.AddSource($"{className}_DxBroadcastMessage.g.cs", SourceText.From(source, Encoding.UTF8));
-            }
-        }
-    }
-
-    private sealed class SyntaxReceiver : ISyntaxReceiver
-    {
-        public List<TypeDeclarationSyntax> CandidateClasses { get; } = [];
-
-        public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
-        {
-            if (syntaxNode is TypeDeclarationSyntax typeDeclarationSyntax)
-            {
-                if (typeDeclarationSyntax.AttributeLists.Count > 0 &&
-                    (typeDeclarationSyntax.Kind() == SyntaxKind.ClassDeclaration ||
-                     typeDeclarationSyntax.Kind() == SyntaxKind.StructDeclaration))
-                {
-                    CandidateClasses.Add(typeDeclarationSyntax);
-                }
-            }
-        }
-    }
-}
+namespace WallstopStudios.DxMessaging.SourceGenerators;
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+[Generator]
+public sealed class DxBroadcastMessageGenerator : ISourceGenerator
+{
+    public void Initialize(GeneratorInitializationContext context)
+    {
+        context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
+    }
+
+    public void Execute(GeneratorExecutionContext context)
+    {
+        if (context.SyntaxReceiver is not SyntaxReceiver receiver)
+        {
+            return;
+        }
+
+        INamedTypeSymbol attributeSymbol = context.Compilation.GetTypeByMetadataName(
+            "DxMessaging.Core.Attributes.DxBroadcastMessageAttribute"
+        );
+
+        foreach (TypeDeclarationSyntax classDeclaration in receiver.CandidateClasses)
+        {
+            SemanticModel model = context.Compilation.GetSemanticModel(classDeclaration.SyntaxTree);
+            ISymbol classSymbol = ModelExtensions.GetDeclaredSymbol(model, classDeclaration);
+
+            if (
+                classSymbol
+                    .GetAttributes()
+                    .Any(attributeData =>
+                        attributeData.AttributeClass.Equals(
+                            attributeSymbol,
+                            SymbolEqualityComparer.Default
+                        )
+                    )
+            )
+            {
+                string namespaceName = classSymbol.ContainingNamespace.ToDisplayString();
+                string className = classSymbol.Name;
+                string typeKind =
+                    classDeclaration.Kind() == SyntaxKind.ClassDeclaration ? "class" : "struct";
+
+                string source = $$"""
+
+                    namespace {{namespaceName}}
+                    {
+                        using DxMessaging.Core.Messages;
+
+                        public partial {{typeKind}} {{className}} : IBroadcastMessage
+                        {
+                            public System.Type MessageType => typeof({{className}});
+                        }
+                    }
+                    
+                    """;
+
+                context.AddSource(
+                    $"{className}_DxBroadcastMessage.g.cs",
+                    SourceText.From(source, Encoding.UTF8)
+                );
+            }
+        }
+    }
+
+    private sealed class SyntaxReceiver : ISyntaxReceiver
+    {
+        public List<TypeDeclarationSyntax> CandidateClasses { get; } = [];
+
+        public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
+        {
+            if (syntaxNode is TypeDeclarationSyntax typeDeclarationSyntax)
+            {
+                if (
+                    typeDeclarationSyntax.AttributeLists.Count > 0
+                    && (
+                        typeDeclarationSyntax.Kind() == SyntaxKind.ClassDeclaration
+                        || typeDeclarationSyntax.Kind() == SyntaxKind.StructDeclaration
+                    )
+                )
+                {
+                    CandidateClasses.Add(typeDeclarationSyntax);
+                }
+            }
+        }
+    }
+}

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxBroadcastMessageGenerator.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 9f20e167b1f4496cae198016fa738fe1
+fileFormatVersion: 2
+guid: 9f20e167b1f4496cae198016fa738fe1
 timeCreated: 1730836618