feat: cleanups and API updates

addons/AetherBind/Editor/GodotScriptPathCache.cs

@@ -14,7 +14,7 @@ namespace GodotHostTest.AetherBind.Editor;
 /// </summary>
 public static class GodotScriptPathCache
 {
-    private static readonly ConcurrentDictionary<Type, string> TypeToPath = new();
+    // private static readonly ConcurrentDictionary<Type, string> TypeToPath = new();
     private static readonly ConcurrentDictionary<string, Type> PathToType = new();
     private static readonly Type GodotObject = typeof(GodotObject);
     private static readonly Type ScriptPathAttribute = typeof(ScriptPathAttribute);
@@ -32,9 +32,9 @@ public static class GodotScriptPathCache
     private static void Initialize()
     {
         GD.Print($"Initializing {nameof(GodotScriptPathCache)}");
-        TypeToPath.Clear();
+        // TypeToPath.Clear();
         PathToType.Clear();
-        _assemblyLoadEventHandler = (sender, args) => CacheScriptsInAssembly(args.LoadedAssembly);
+        _assemblyLoadEventHandler = (_, args) => CacheScriptsInAssembly(args.LoadedAssembly);
         AppDomain.CurrentDomain.AssemblyLoad += _assemblyLoadEventHandler;
         foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
             CacheScriptsInAssembly(assembly);
@@ -49,7 +49,7 @@ public static class GodotScriptPathCache
                 if (type.GetCustomAttributes(ScriptPathAttribute, false).FirstOrDefault() is ScriptPathAttribute
                     scriptPath)
                 {
-                    TypeToPath[type] = scriptPath.Path;
+                    // TypeToPath[type] = scriptPath.Path;
                     PathToType[scriptPath.Path] = type;
                 }
         }
@@ -60,31 +60,31 @@ public static class GodotScriptPathCache
         GD.Print($"Deinitializing {nameof(GodotScriptPathCache)}");
         AppDomain.CurrentDomain.AssemblyLoad -= _assemblyLoadEventHandler;
         _assemblyLoadEventHandler = null;
-        TypeToPath.Clear();
+        // TypeToPath.Clear();
         PathToType.Clear();
     }
 
-    public static bool TryGetScriptPath(Type type, [MaybeNullWhen(false)] out string path)
-    {
-        InitializeIfNeeded();
-        return TypeToPath.TryGetValue(type, out path);
-    }
+    // public static bool TryGetScriptPath(Type type, [MaybeNullWhen(false)] out string path)
+    // {
+    //     InitializeIfNeeded();
+    //     return TypeToPath.TryGetValue(type, out path);
+    // }
 
-    public static Script GetScriptFromType(Type type)
-    {
-        InitializeIfNeeded();
-        return TryGetScriptPath(type, out string path)
-            ? GD.Load<Script>(path)
-            : throw new InvalidOperationException("Script path not found in cache.");
-    }
+    // public static Script GetScriptFromType(Type type)
+    // {
+    //     InitializeIfNeeded();
+    //     return TryGetScriptPath(type, out string path)
+    //         ? GD.Load<Script>(path)
+    //         : throw new InvalidOperationException("Script path not found in cache.");
+    // }
 
-    public static Script GetScriptFromType<T>()
-    {
-        InitializeIfNeeded();
-        return GetScriptFromType(typeof(T));
-    }
+    // public static Script GetScriptFromType<T>()
+    // {
+    //     InitializeIfNeeded();
+    //     return GetScriptFromType(typeof(T));
+    // }
 
-    public static bool TryGetTypeFromPath(string path, [MaybeNullWhen(false)] out Type type)
+    private static bool TryGetTypeFromPath(string path, [MaybeNullWhen(false)] out Type type)
     {
         InitializeIfNeeded();
         return PathToType.TryGetValue(path, out type);

addons/AetherBind/Editor/Plugin.cs

@@ -78,15 +78,20 @@ public partial class Plugin : EditorPlugin
         // mark debounce as completed
         _sceneTreeTimer = null;
 
-
         // check that the instance is still valid after debouncing (could have been disposed)
         if (!IsInstanceValid(sceneRoot)) return;
 
-        var sceneNodes = sceneRoot.FindChildren("*").Where(node => node.Owner == sceneRoot).Append(sceneRoot).ToList();
-        GD.Print($"Updating injection for root {sceneRoot.Name}");
+        // get all nodes belonging to this root
+        var sceneNodes = sceneRoot
+            .FindChildren("*")
+            .Where(node => node.Owner == sceneRoot)
+            .Append(sceneRoot)
+            .ToList();
+        // GD.Print($"Updating injection for root {sceneRoot.Name} ({sceneNodes.Count} nodes)");
 
         // look for the service source
-        var serviceSource = sceneNodes.Where(child => child.IsServiceSource())
+        var serviceSource = sceneNodes
+            .Where(child => child.IsServiceSource())
             .Single(out var failureReason);
 
         switch (failureReason)

addons/AetherBind/ServiceSource.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using Godot;
 using Microsoft.Extensions.Logging;
 using OwofGames.AetherBind;
@@ -7,14 +6,31 @@ using OwofGames.GodotLume;
 
 namespace GodotHostTest.AetherBind;
 
+/// <summary>
+///     A node that provides injected services to other nodes.
+/// </summary>
 [Icon("res://addons/AetherBind/ServiceSource.svg")]
 public partial class ServiceSource : Node
 {
     private static readonly string RootScopeQualifiedName = typeof(RootScope).AssemblyQualifiedName!;
+
+    /// <summary>
+    ///     List of nodes that must be injected. This list will be automatically populated with all nodes in this object's
+    ///     editor scene that have at least one [Inject] field or method.
+    /// </summary>
     [Export] protected Node?[] InjectedNodes = [];
+
+    /// <summary>
+    ///     Name of the scope for the services built by this service source.
+    /// </summary>
     [Export] private string _serviceScope = RootScopeQualifiedName;
 
-    internal void ResolveInjectedNodes(IProvider provider, Delegate? onScopeCreated)
+    /// <summary>
+    ///     Inject the required services in <see cref="InjectedNodes" />.
+    /// </summary>
+    /// <param name="provider">The service provider.</param>
+    /// <param name="onScopeCreated">A callback method invoked with this scope's provider, if a scope was created.</param>
+    internal void ResolveInjectedNodes(IProvider provider, Action<IProvider>? onScopeCreated)
     {
         var logger = provider.Get<ILogger<ServiceSource>>();
 
@@ -24,16 +40,11 @@ public partial class ServiceSource : Node
             // create the scoped provider
             var serviceScope = ScopeTypesAndNames.GetType(_serviceScope);
             provider = provider.GetScopedProvider(serviceScope);
-            // invoke onScopeCreated, if present
-            if (onScopeCreated != null)
-            {
-                var parameters = onScopeCreated.Method
-                    .GetParameters()
-                    .Select(parameterInfo => provider.Get(parameterInfo.ParameterType))
-                    .ToArray();
-                onScopeCreated.DynamicInvoke(parameters);
-            }
 
+            // invoke onScopeCreated, if present
+            onScopeCreated?.Invoke(provider);
+
+            // invoke overridden callback
             OnScopeCreated(provider);
         }
         else if (onScopeCreated != null)
@@ -55,6 +66,12 @@ public partial class ServiceSource : Node
     }
 
     // TODO: also add source generator to mark methods in derived classes with [OnScopeCreated] and perform parameter injection
+    /// <summary>
+    ///     This method is invoked as soon as the scope for the services is created, but before the services are injected into
+    ///     the <see cref="InjectedNodes" />. Override this method in derived classes to perform custom initialization steps
+    ///     for the services, like setting <see cref="ValueProvider{T}" />s.
+    /// </summary>
+    /// <param name="serviceProvider">Lume's service provider.</param>
     protected virtual void OnScopeCreated(IProvider serviceProvider)
     {
     }