Improve ServiceWiringObserver (#259)

cspray · web-flow · commit 9ab14f800d6f · 2022-09-05T08:10:13.000-04:00
* Improve ServiceWiringObserver

* Fix psalm inference
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased Changes
 
+## [v2.0.0-beta3](https://github.com/cspray/annotated-container/tree/v2.0.0-beta3) - 2022-09-05
+
+### Added
+
+- Added a new `Bootstrap\ServiceGatherer::getServicesWithAttribute` method that allows retrieving all services and definitions that have an Attribute of a given type.
+
+### Fixed
+
+- Fixed a bug where the `Bootstrap\ServiceWiringObserver` was not profile aware and could result in attempting to make a service the Container was unaware of.
+
+## [v2.0.0-beta2](https://github.com/cspray/annotated-container/tree/v2.0.0-beta2) - 2022-09-04
+
+### Changed
+
+- The provided `Bootstrap\ServiceWiringObserver` now provides an array of `Bootstrap\ServiceFromServiceDefinition` which provides the `Definition\ServiceDefinition` as well as the corresponding service. This provides access to the new `Definition\ServiceDefinition::getAttribute` method which could be useful in contexts where service wiring occurs.
+
 ## [v2.0.0-beta1](https://github.com/cspray/annotated-container/tree/v2.0.0-beta1) - 2022-09-04
 
 Version 2 represents significant improvements but includes backwards-breaking changes. If you run into problems migrating from v1 to v2 please [submit an Issue](https://github.com/cspray/annotated-container/issues/new).
diff --git a/VERSION b/VERSION
@@ -1 +1 @@
-dev-main
+v2.0.0-beta3
diff --git a/src/Bootstrap/ServiceGatherer.php b/src/Bootstrap/ServiceGatherer.php
@@ -13,4 +13,10 @@ interface ServiceGatherer {
      */
     public function getServicesForType(string $type) : array;
 
+    /**
+     * @param class-string<T> $attributeType
+     * @return ServiceFromServiceDefinition<T>[]
+     */
+    public function getServicesWithAttribute(string $attributeType) : array;
+
 }
diff --git a/src/Bootstrap/ServiceWiringObserver.php b/src/Bootstrap/ServiceWiringObserver.php
@@ -4,7 +4,9 @@
 
 use Cspray\AnnotatedContainer\AnnotatedContainer;
 use Cspray\AnnotatedContainer\Definition\ContainerDefinition;
+use Cspray\AnnotatedContainer\Definition\ProfilesAwareContainerDefinition;
 use Cspray\AnnotatedContainer\Definition\ServiceDefinition;
+use Cspray\AnnotatedContainer\Profiles\ActiveProfiles;
 
 abstract class ServiceWiringObserver implements Observer {
 
@@ -23,10 +25,16 @@ final public function beforeContainerCreation(ContainerDefinition $containerDefi
     final public function afterContainerCreation(ContainerDefinition $containerDefinition, AnnotatedContainer $container) : void {
         $serviceGatherer = new class($containerDefinition, $container) implements ServiceGatherer {
 
+            private readonly ContainerDefinition $containerDefinition;
+
             public function __construct(
-                private readonly ContainerDefinition $containerDefinition,
+                ContainerDefinition $containerDefinition,
                 private readonly AnnotatedContainer $container
-            ) {}
+            ) {
+                $activeProfiles = $container->get(ActiveProfiles::class);
+                assert($activeProfiles instanceof ActiveProfiles);
+                $this->containerDefinition = new ProfilesAwareContainerDefinition($containerDefinition, $activeProfiles->getProfiles());
+            }
 
             public function getServicesForType(string $type) : array {
                 /** @var array<array-key, object> $services */
@@ -41,26 +49,49 @@ public function getServicesForType(string $type) : array {
                     if (is_a($serviceType, $type, true)) {
                         $service = $this->container->get($serviceType);
                         assert($service instanceof $type);
-                        $services[] = new class($service, $serviceDefinition) implements ServiceFromServiceDefinition {
+                        $services[] = $this->createServiceFromServiceDefinition($service, $serviceDefinition);
+                    }
+                }
 
-                            public function __construct(
-                                private readonly object $service,
-                                private readonly ServiceDefinition $definition
-                            ) {}
+                return $services;
+            }
 
-                            public function getService() : object {
-                                return $this->service;
-                            }
+            public function getServicesWithAttribute(string $attributeType) : array {
+                $services = [];
+                foreach ($this->containerDefinition->getServiceDefinitions() as $serviceDefinition) {
+                    if ($serviceDefinition->isAbstract()) {
+                        continue;
+                    }
 
-                            public function getDefinition() : ServiceDefinition {
-                                return $this->definition;
-                            }
-                        };
+                    $serviceAttribute = $serviceDefinition->getAttribute();
+                    if (!($serviceAttribute instanceof $attributeType)) {
+                        continue;
                     }
-                }
 
+                    $service = $this->container->get($serviceDefinition->getType()->getName());
+                    assert(is_object($service));
+                    $services[] = $this->createServiceFromServiceDefinition($service, $serviceDefinition);
+                }
                 return $services;
             }
+
+            private function createServiceFromServiceDefinition(object $service, ServiceDefinition $serviceDefinition) : ServiceFromServiceDefinition {
+                return new class($service, $serviceDefinition) implements ServiceFromServiceDefinition {
+                    public function __construct(
+                        private readonly object $service,
+                        private readonly ServiceDefinition $definition
+                    ) {}
+
+                    public function getService() : object {
+                        return $this->service;
+                    }
+
+                    public function getDefinition() : ServiceDefinition {
+                        return $this->definition;
+                    }
+                };
+
+            }
         };
         $this->wireServices($container, $serviceGatherer);
     }
diff --git a/test/BootstrapTest.php b/test/BootstrapTest.php
@@ -15,6 +15,7 @@
 use Cspray\AnnotatedContainer\Compile\ContainerDefinitionBuilderContextConsumer;
 use Cspray\AnnotatedContainer\ContainerFactory\ParameterStore;
 use Cspray\AnnotatedContainer\Helper\TestLogger;
+use Cspray\AnnotatedContainerFixture\CustomServiceAttribute\Repository;
 use Cspray\AnnotatedContainerFixture\Fixtures;
 use PHPUnit\Framework\TestCase;
 use org\bovigo\vfs\vfsStream as VirtualFilesystem;
@@ -519,4 +520,156 @@ protected function wireServices(AnnotatedContainer $container, ServiceGatherer $
         ], $actualServices);
     }
 
+    public function testServiceWiringObserverByAttributes() : void {
+        $directoryResolver = new FixtureBootstrappingDirectoryResolver();
+
+        $goodXml = <<<XML
+<?xml version="1.0" encoding="UTF-8" ?>
+<annotatedContainer xmlns="https://annotated-container.cspray.io/schema/annotated-container.xsd">
+    <scanDirectories>
+        <source>
+            <dir>CustomServiceAttribute</dir>
+        </source>
+    </scanDirectories>
+</annotatedContainer>
+XML;
+
+        VirtualFilesystem::newFile('annotated-container.xml')
+            ->withContent($goodXml)
+            ->at($this->vfs);
+
+        $bootstrap = new Bootstrap(directoryResolver: $directoryResolver);
+
+        $observer = new class extends ServiceWiringObserver {
+
+            private ?AnnotatedContainer $container = null;
+            private array $services = [];
+
+            public function getAnnotatedContainer() : ?AnnotatedContainer {
+                return $this->container;
+            }
+
+            public function getServices() : array {
+                return $this->services;
+            }
+
+            protected function wireServices(AnnotatedContainer $container, ServiceGatherer $gatherer) : void {
+                $this->container = $container;
+                $this->services = $gatherer->getServicesWithAttribute(Repository::class);
+            }
+        };
+        $bootstrap->addObserver($observer);
+
+        $container = $bootstrap->bootstrapContainer(['default', 'test']);
+
+        $actual = $observer->getServices();
+        $actualServices = array_map(fn(ServiceFromServiceDefinition $fromServiceDefinition) => $fromServiceDefinition->getService(), $actual);
+
+        self::assertSame($container, $observer->getAnnotatedContainer());
+        self::assertSame([
+            $container->get(Fixtures::customServiceAttribute()->myRepo()->getName()),
+        ], $actualServices);
+    }
+
+    public function testServiceWiringObserverByTypeProfileAware() : void {
+        $directoryResolver = new FixtureBootstrappingDirectoryResolver();
+
+        $goodXml = <<<XML
+<?xml version="1.0" encoding="UTF-8" ?>
+<annotatedContainer xmlns="https://annotated-container.cspray.io/schema/annotated-container.xsd">
+    <scanDirectories>
+        <source>
+            <dir>ProfileResolvedServices</dir>
+        </source>
+    </scanDirectories>
+</annotatedContainer>
+XML;
+
+        VirtualFilesystem::newFile('annotated-container.xml')
+            ->withContent($goodXml)
+            ->at($this->vfs);
+
+        $bootstrap = new Bootstrap(directoryResolver: $directoryResolver);
+
+        $observer = new class extends ServiceWiringObserver {
+
+            private ?AnnotatedContainer $container = null;
+            private array $services = [];
+
+            public function getAnnotatedContainer() : ?AnnotatedContainer {
+                return $this->container;
+            }
+
+            public function getServices() : array {
+                return $this->services;
+            }
+
+            protected function wireServices(AnnotatedContainer $container, ServiceGatherer $gatherer) : void {
+                $this->container = $container;
+                $this->services = $gatherer->getServicesForType(Fixtures::profileResolvedServices()->fooInterface()->getName());
+            }
+        };
+        $bootstrap->addObserver($observer);
+
+        $container = $bootstrap->bootstrapContainer(['default', 'prod']);
+
+        $actual = $observer->getServices();
+
+        $actualServices = array_map(fn(ServiceFromServiceDefinition $fromServiceDefinition) => $fromServiceDefinition->getService(), $actual);
+
+        usort($actualServices, fn($a, $b) => $a::class <=> $b::class);
+
+        self::assertSame($container, $observer->getAnnotatedContainer());
+        self::assertSame([
+            $container->get(Fixtures::profileResolvedServices()->prodImplementation()->getName()),
+        ], $actualServices);
+    }
+
+    public function testServiceWiringObserverByAttributesProfileAware() : void {
+        $directoryResolver = new FixtureBootstrappingDirectoryResolver();
+
+        $goodXml = <<<XML
+<?xml version="1.0" encoding="UTF-8" ?>
+<annotatedContainer xmlns="https://annotated-container.cspray.io/schema/annotated-container.xsd">
+    <scanDirectories>
+        <source>
+            <dir>CustomServiceAttribute</dir>
+        </source>
+    </scanDirectories>
+</annotatedContainer>
+XML;
+
+        VirtualFilesystem::newFile('annotated-container.xml')
+            ->withContent($goodXml)
+            ->at($this->vfs);
+
+        $bootstrap = new Bootstrap(directoryResolver: $directoryResolver);
+
+        $observer = new class extends ServiceWiringObserver {
+
+            private ?AnnotatedContainer $container = null;
+            private array $services = [];
+
+            public function getAnnotatedContainer() : ?AnnotatedContainer {
+                return $this->container;
+            }
+
+            public function getServices() : array {
+                return $this->services;
+            }
+
+            protected function wireServices(AnnotatedContainer $container, ServiceGatherer $gatherer) : void {
+                $this->container = $container;
+                $this->services = $gatherer->getServicesWithAttribute(Repository::class);
+            }
+        };
+        $bootstrap->addObserver($observer);
+
+        // The Repository is only active under 'test' profile and should not be included
+        $container = $bootstrap->bootstrapContainer(['default', 'dev']);
+
+        self::assertSame($container, $observer->getAnnotatedContainer());
+        self::assertEmpty($observer->getServices());
+    }
+
 }
