com.wallstop-studios.dxmessaging 1.0.5 → 2.0.0-rc01

package/Runtime/Unity/MessagingComponent.cs

@@ -4,12 +4,17 @@
     using System;
     using System.Collections.Generic;
     using UnityEngine;
-    
+
     [DisallowMultipleComponent]
     public sealed class MessagingComponent : MonoBehaviour
     {
+        [SerializeField]
+        private bool _emitMessagesWhenDisabled;
+
         private MessageHandler _messageHandler;
-        private readonly Dictionary<MonoBehaviour, MessageRegistrationToken> _registeredListeners = new Dictionary<MonoBehaviour, MessageRegistrationToken>();
+
+        private readonly Dictionary<MonoBehaviour, MessageRegistrationToken> _registeredListeners =
+            new Dictionary<MonoBehaviour, MessageRegistrationToken>();
 
         public MessageRegistrationToken Create(MonoBehaviour listener)
         {
@@ -20,9 +25,7 @@
 
             if (gameObject.GetInstanceID() != listener.gameObject.GetInstanceID())
             {
-                throw new ArgumentException(string.Format(
-                    "Cannot create a RegistrationToken without an valid owner. {0}.",
-                    listener.gameObject.GetInstanceID()));
+                throw new ArgumentException($"Cannot create a RegistrationToken without an valid owner. {listener.gameObject.GetInstanceID()}.");
             }
 
             if (_registeredListeners.TryGetValue(listener, out MessageRegistrationToken createdToken))
@@ -37,14 +40,17 @@
                 {
                     active = true
                 };
-                MessagingDebug.Log(LogLevel.Debug, "Creating MessageHandler for componentType {0}, GameObject name: {1}, InstanceId: {2}.",
-                    listener.GetType(), listener.gameObject.name, (InstanceId) gameObject);
+                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,
+                MessagingDebug.Log(
+                    LogLevel.Debug,
                     "Using existing MessageHandler for componentType {0}, GameObject name: {1}, InstanceId: {2}.",
-                    listener.GetType(), listener.gameObject.name, (InstanceId) gameObject);
+                    listener.GetType(), listener.gameObject.name, (InstanceId)gameObject);
             }
 
             createdToken = MessageRegistrationToken.Create(_messageHandler);
@@ -64,10 +70,15 @@
 
         private void ToggleMessageHandler(bool newActive)
         {
+            if (!newActive && _emitMessagesWhenDisabled)
+            {
+                return;
+            }
+
             if (_messageHandler != null && _messageHandler.active != newActive)
             {
                 _messageHandler.active = newActive;
             }
         }
     }
-}
+}

package/Runtime/WallstopStudios.DxMessaging.asmdef

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

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

@@ -0,0 +1,75 @@
+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

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

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

@@ -0,0 +1,77 @@
+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

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

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxTargetedMessageGenerator.cs

@@ -0,0 +1,77 @@
+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 DxTargetedMessageGenerator : 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.DxTargetedMessageAttribute");
+
+        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}} : ITargetedMessage
+                                      {
+                                          public System.Type MessageType => typeof({{className}});
+                                      }
+                                  }
+
+                                  """;
+
+                context.AddSource($"{className}_DxTargetedMessage.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/DxTargetedMessageGenerator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d2d62958607d4a9284c0151e3ab03806
+timeCreated: 1730836745

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxUntargetedMessageGenerator.cs

@@ -0,0 +1,78 @@
+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 DxUntargetedMessageGenerator : 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.DxUntargetedMessageAttribute");
+
+        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}} : IUntargetedMessage
+                                      {
+                                          public System.Type MessageType => typeof({{className}});
+                                      }
+                                  }
+
+                                  """;
+
+                context.AddSource($"{className}_DxUntargetedMessage.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/DxUntargetedMessageGenerator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d0d88616d75247aab6b3a78bc8078418
+timeCreated: 1730836844

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <LangVersion>latest</LangVersion>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.1">
+        <PrivateAssets>all</PrivateAssets>
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      </PackageReference>
+      <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0">
+		<PrivateAssets>all</PrivateAssets>
+	  </PackageReference>
+      <PackageReference Include="System.Collections.Immutable" Version="5.0.0">
+		<PrivateAssets>all</PrivateAssets>
+	  </PackageReference>
+    </ItemGroup>
+
+</Project>

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.csproj.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e4915fed9609ee64f9cbdaaf0324b3d0
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.meta

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

package/SourceGenerators.meta

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