add parent service

Author: smarx-shopmacher

DependencyInjection/Compiler/ServiceAliasPass.php

@@ -24,7 +24,7 @@ public function process(ContainerBuilder $container)
 
             if (true === $this->definitionHasAnnotation($definition, ServiceAlias::class)) {
                 /** @var ServiceAlias[] $serviceAliases */
-                $serviceAliases = $this->getDefinitionAnnotation($definition, ServiceAlias::class);
+                $serviceAliases = $this->getDefinitionAnnotations($definition, ServiceAlias::class);
 
                 foreach ($serviceAliases as $alias) {
                     $container->setAlias($alias->getName(), $serviceId);

DependencyInjection/Compiler/ServiceTagArgumentPass.php

@@ -23,9 +23,9 @@ public function process(ContainerBuilder $container)
             }
 
             /** @var ServiceTagArgument[] $arguments */
-            $arguments = $this->getDefinitionAnnotation($definition, ServiceTagArgument::class);
+            $arguments = $this->getDefinitionAnnotations($definition, ServiceTagArgument::class);
             /** @var ServiceTag[] $serviceTags */
-            $serviceTags = $this->getDefinitionAnnotation($definition, ServiceTag::class);
+            $serviceTags = $this->getDefinitionAnnotations($definition, ServiceTag::class);
 
             $attributesByTag = [];
 

DependencyInjection/Compiler/ServiceTagPass.php

@@ -23,7 +23,7 @@ public function process(ContainerBuilder $container)
             }
 
             /** @var ServiceTag[] $tags */
-            $tags = $this->getDefinitionAnnotation($definition, ServiceTag::class);
+            $tags = $this->getDefinitionAnnotations($definition, ServiceTag::class);
 
             foreach ($tags as $tag) {
                 $definition->addTag($tag->getName(), $tag->getAttributes());

README.MD

@@ -241,5 +241,23 @@ class SomeClass {
 
     }   
 }
+```
+
+#### Example 7: Assign Parent service
+
+If your current service requires a parent service, just annotate your service class with `@ParentService`, the compilerpass
+will redefine your service as a ChildDefinition and replace it in the service container
+
+```php
+<?php
 
+namespace App;
+
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\ParentService;
+
+/**
+ * @ParentService("App\Service\ParentService")
+ */
+class ChildService {
+}
 ```

SimaServiceAnnotationsBundle.php

@@ -6,6 +6,7 @@
 
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\DependencyInjectionPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\NoServicePass;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ParentServicePass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceAliasPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceTagArgumentPass;
 use SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler\ServiceTagPass;
@@ -23,6 +24,7 @@ public function build(ContainerBuilder $container)
             ->addCompilerPass(new ServiceAliasPass())
             ->addCompilerPass(new DependencyInjectionPass())
             ->addCompilerPass(new ServiceTagArgumentPass())
+            ->addCompilerPass(new ParentServicePass())
             ->addCompilerPass(new NoServicePass());
     }
 }

Utils/CompilerPassServiceAnnotationTrait.php

@@ -114,26 +114,37 @@ private function getDefinitionCacheKey(Definition $definition): string
         return \md5($definition->getClass());
     }
 
-    private function getDefinitionAnnotation(Definition $definition, string $annotationClass): array
+    private function findDefinitionAnnotation(Definition $definition, string $annotationClass): ?object
     {
         if (false === $this->definitionHasAnnotation($definition, $annotationClass)) {
-            return [];
+            return null;
         }
 
         $annotations = \array_filter(
             $this->getDefinitionAnnotations($definition),
             fn($annotation) => $annotation instanceof $annotationClass
         );
 
-        return \array_values($annotations);
+        return \array_values($annotations)[0] ?? null;
     }
 
-    private function getDefinitionAnnotations(Definition $definition): array
+    private function getDefinitionAnnotations(Definition $definition, ?string $annotationClass = null): array
     {
         $this->warmupDefinitionAnnotationCache($definition);
         $cacheKey = $this->getDefinitionCacheKey($definition);
 
-        return $this->annotationCache[$cacheKey] ?? [];
+        $annotations = $this->annotationCache[$cacheKey] ?? [];
+
+        if (null === $annotationClass) {
+            return $annotations;
+        }
+
+        return \array_values(
+            \array_filter(
+                $annotations,
+                fn($annotation) => $annotation instanceof $annotationClass
+            )
+        );
     }
 
     private function fullAnnotationScan(Definition $definition): ClassAnnotationScan

Utils/ReflectionCacheTrait.php

@@ -12,7 +12,7 @@ trait ReflectionCacheTrait
 {
     private array $classReflectionCache = [];
 
-    private function getClassReflection(string $className): ?ReflectionClass
+    private function getClassReflection(string $className, bool $recursive = false): ?ReflectionClass
     {
         $cacheKey = \md5($className);
 
@@ -24,9 +24,43 @@ private function getClassReflection(string $className): ?ReflectionClass
             }
         }
 
+        if (
+            true === $recursive
+            && false !== $this->classReflectionCache[$cacheKey]->getParentClass()
+            && false === \array_key_exists($cacheKey, $this->classReflectionCache)
+        ) {
+            $this->getClassReflection($this->classReflectionCache[$cacheKey]->getParentClass());
+        }
+
         return $this->classReflectionCache[$cacheKey] ?? null;
     }
 
+    /**
+     * @return ReflectionProperty[]
+     */
+    public function getPropertyReflections(string $className, bool $recursive = false, int $filter = null): array
+    {
+        $classReflection = $this->getClassReflection($className, $recursive);
+
+        $properties = $classReflection->getProperties();
+
+        if (false !== $classReflection->getParentClass() && true === $recursive) {
+            $parentProperties = $this->getPropertyReflections($classReflection->getParentClass()->getName(), $recursive, $filter);
+
+            $filtered = \array_filter($parentProperties, function (ReflectionProperty $parentProperty) use ($properties) {
+                $childDefinition = \array_filter($properties, function (ReflectionProperty $childProperty) use ($parentProperty) {
+                    return $childProperty->getName() === $parentProperty->getName()
+                        && $childProperty->getDeclaringClass()->getName() === $parentProperty->getDeclaringClass()->getName();
+                });
+                return \count($childDefinition) === 0;
+            });
+
+            $properties = \array_merge($filtered, $properties);
+        }
+
+        return $properties;
+    }
+
     public function getMethodReflection(string $className, string $methodName): ?ReflectionMethod
     {
         $rc = $this->getClassReflection($className);