Reset singletons

Author: brendt

packages/container/src/GenericContainer.php

@@ -30,8 +30,11 @@ public function __construct(
         /** @var ArrayIterator<array-key, mixed> $definitions */
         private(set) ArrayIterator $definitions = new ArrayIterator(),
 
-        /** @var ArrayIterator<array-key, mixed> $singletons */
-        private(set) ArrayIterator $singletons = new ArrayIterator(),
+        /** @var ArrayIterator<array-key, mixed> $singletonDefinitions */
+        private(set) ArrayIterator $singletonDefinitions = new ArrayIterator(),
+
+        /** @var ArrayIterator<array-key, object> $resolvedSingletons */
+        private(set) ArrayIterator $resolvedSingletons = new ArrayIterator(),
 
         /** @var ArrayIterator<array-key, class-string> $initializers */
         private(set) ArrayIterator $initializers = new ArrayIterator(),
@@ -61,7 +64,7 @@ public function setDefinitions(array $definitions): self
 
     public function setSingletons(array $singletons): self
     {
-        $this->singletons = new ArrayIterator($singletons);
+        $this->resolvedSingletons = new ArrayIterator($singletons);
 
         return $this;
     }
@@ -97,7 +100,7 @@ public function getDefinitions(): array
      */
     public function getSingletons(?string $interface = null): array
     {
-        $singletons = $this->singletons->getArrayCopy();
+        $singletons = $this->resolvedSingletons->getArrayCopy();
 
         if (is_null($interface)) {
             return $singletons;
@@ -134,24 +137,34 @@ public function register(string $className, callable $definition): self
 
     public function unregister(string $className, bool $tagged = false): self
     {
-        unset($this->definitions[$className], $this->singletons[$className]);
+        unset($this->definitions[$className]);
+        unset($this->singletonDefinitions[$className]);
+        unset($this->resolvedSingletons[$className]);
 
         if ($tagged) {
-            $singletons = array_filter(
-                array: $this->getSingletons(),
-                callback: static fn (mixed $_, string $key) => ! str_starts_with($key, "{$className}#"),
-                mode: \ARRAY_FILTER_USE_BOTH,
-            );
+            foreach ($this->singletonDefinitions as $key => $definition) {
+                if (! str_starts_with($key, "{$className}#")) {
+                    continue;
+                }
+
+                unset($this->singletonDefinitions[$key]);
+            }
 
-            $this->setSingletons($singletons);
+            foreach ($this->resolvedSingletons as $key => $definition) {
+                if (! str_starts_with($key, "{$className}#")) {
+                    continue;
+                }
+
+                unset($this->resolvedSingletons[$key]);
+            }
         }
 
         return $this;
     }
 
     public function has(string $className, null|string|UnitEnum $tag = null): bool
     {
-        return isset($this->definitions[$className]) || isset($this->singletons[$this->resolveTaggedName($className, $tag)]);
+        return isset($this->definitions[$className]) || isset($this->singletonDefinitions[$this->resolveTaggedName($className, $tag)]);
     }
 
     public function singleton(string $className, mixed $definition, null|string|UnitEnum $tag = null): self
@@ -160,9 +173,9 @@ public function singleton(string $className, mixed $definition, null|string|Unit
             $tag = $definition->tag;
         }
 
-        $className = $this->resolveTaggedName($className, $tag);
+        $dependencyName = $this->resolveTaggedName($className, $tag);
 
-        $this->singletons[$className] = $definition;
+        $this->singletonDefinitions[$dependencyName] = $definition;
 
         return $this;
     }
@@ -350,12 +363,18 @@ private function resolveDependency(string $className, null|string|UnitEnum $tag
 
         $dependencyName = $this->resolveTaggedName($className, $tag);
 
+        // Check if a resolved singleton is present
+        if ($instance = $this->resolvedSingletons[$dependencyName] ?? null) {
+            $this->resolveChain()->add($class);
+
+            return $instance;
+        }
+
         // Check if the class has been registered as a singleton.
-        if ($instance = $this->singletons[$dependencyName] ?? null) {
-            if ($instance instanceof Closure) {
-                $instance = $instance($this);
-                $this->singletons[$className] = $instance;
-            }
+        if ($singletonDefinition = $this->singletonDefinitions[$dependencyName] ?? null) {
+            $instance = $singletonDefinition instanceof Closure ? $singletonDefinition($this) : $singletonDefinition;
+
+            $this->resolvedSingletons[$dependencyName] = $instance;
 
             $this->resolveChain()->add($class);
 
@@ -696,6 +715,8 @@ public function addResettable(string|ClassReflector $resettableClass): Container
 
     public function reset(): self
     {
+        $this->resolvedSingletons = new ArrayIterator();
+
         foreach ($this->resettables as $resettableClass) {
             /** @var Resettable $resettable */
             $resettable = $this->get($resettableClass);

packages/container/tests/ContainerTest.php

@@ -74,6 +74,12 @@
  */
 final class ContainerTest extends TestCase
 {
+    protected function setUp(): void
+    {
+        parent::setUp();
+        SingletonClass::$count = 0;
+    }
+
     public function test_get_with_autowire(): void
     {
         $container = new GenericContainer();
@@ -692,16 +698,23 @@ public function test_returns_decorator_without_constructor(): void
         $this->assertInstanceOf(DecoratorWithoutConstructor::class, $instance);
     }
 
-    public function test_resettables(): void
+    public function test_reset(): void
     {
         ResettableDependency::$reset = false;
 
         $container = new GenericContainer();
 
         $container->addResettable(ResettableDependency::class);
+        $container->singleton(SingletonClass::class, fn () => new SingletonClass());
+        $container->get(SingletonClass::class);
+        $container->get(SingletonClass::class);
+        $this->assertSame(1, SingletonClass::$count);
 
         $container->reset();
 
+        $container->get(SingletonClass::class);
+        $container->get(SingletonClass::class);
+        $this->assertSame(2, SingletonClass::$count); // constructed twice, once before and once after reset
         $this->assertTrue(ResettableDependency::$reset);
     }
 }