add missing files

Author: smarx-shopmacher

Annotation/EventListener.php

@@ -0,0 +1,44 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation;
+
+use Doctrine\Common\Annotations\Annotation\Target;
+
+/**
+ * @Annotation
+ * @Target("CLASS")
+ */
+class EventListener
+{
+    private string $eventTag;
+    private string $event;
+    private array $attributes = [];
+
+    public function __construct(array $values = [])
+    {
+        $this->event = $values['event'] ?? $values['value'];
+        $this->eventTag = $values['eventTag'] ?? 'kernel.event_listener';
+
+        unset($values['value']);
+        unset($values['name']);
+
+        $this->attributes['event'] = $this->event;
+        $this->attributes = $values;
+    }
+
+    public function getEvent(): string
+    {
+        return $this->event;
+    }
+
+    public function getEventTag(): string
+    {
+        return $this->eventTag;
+    }
+
+    public function getAttributes(): array
+    {
+        return $this->attributes;
+    }
+}

Annotation/NotShared.php

@@ -0,0 +1,15 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation;
+
+use Doctrine\Common\Annotations\Annotation\Target;
+
+/**
+ * @Annotation
+ * @Target("CLASS")
+ */
+class NotShared
+{
+
+}

Annotation/ParentService.php

@@ -0,0 +1,25 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation;
+
+use Doctrine\Common\Annotations\Annotation\Target;
+
+/**
+ * @Annotation
+ * @Target("CLASS")
+ */
+class ParentService
+{
+    private string $parent;
+
+    public function __construct(array $values = [])
+    {
+        $this->parent = $values['parent'] ?? $values['value'];
+    }
+
+    public function getParent(): string
+    {
+        return $this->parent;
+    }
+}

Annotation/ServiceCall.php

@@ -0,0 +1,14 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation;
+
+use Doctrine\Common\Annotations\Annotation\Target;
+
+/**
+ * @Annotation
+ * @Target("METHOD")
+ */
+class ServiceCall
+{
+}

DependencyInjection/Compiler/DefinitionManipulationPass.php

@@ -0,0 +1,29 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler;
+
+
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\NotShared;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\CompilerPassServiceAnnotationTrait;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class DefinitionManipulationPass implements CompilerPassInterface
+{
+    use CompilerPassServiceAnnotationTrait;
+
+    public function process(ContainerBuilder $container)
+    {
+        foreach ($container->getDefinitions() as $definition) {
+            if (
+                false === $this->definitionHasValidClass($definition)
+                || false === $this->definitionHasAnnotation($definition, NotShared::class)
+            ) {
+                continue;
+            }
+
+            $definition->setShared(false);
+        }
+    }
+}

DependencyInjection/Compiler/ParentServicePass.php

@@ -0,0 +1,56 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler;
+
+use ReflectionProperty;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\ParentService;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\CompilerPassServiceAnnotationTrait;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\ObjectCloner;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\ObjectClonerContext;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\ReflectionCacheTrait;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+class ParentServicePass implements CompilerPassInterface
+{
+    use ReflectionCacheTrait;
+    use CompilerPassServiceAnnotationTrait;
+
+    public function process(ContainerBuilder $container)
+    {
+        foreach ($container->getDefinitions() as $serviceId => $definition) {
+            if (
+                false === $this->definitionHasValidClass($definition)
+                || false === $this->definitionHasAnnotation($definition, ParentService::class)
+            ) {
+                continue;
+            }
+
+            /** @var ParentService $parentAnnotation */
+            $parentAnnotation = $this->findDefinitionAnnotation($definition, ParentService::class);
+
+            if (null === $parentAnnotation) {
+                continue;
+            }
+
+            if ($definition instanceof ChildDefinition) {
+                $definition->setParent($parentAnnotation->getParent());
+            } else {
+                /** @var ChildDefinition $childDefinition */
+                $childDefinition = ObjectCloner::clone(
+                    $definition,
+                    ChildDefinition::class,
+                    new ObjectClonerContext([
+                        ObjectClonerContext::CONSTRUCT => ['parent' => $parentAnnotation->getParent()]
+                    ])
+                );
+
+                $container->removeDefinition($serviceId);
+                $container->setDefinition($serviceId, $childDefinition);
+            }
+        }
+    }
+}

DependencyInjection/Compiler/ServiceCallPass.php

@@ -0,0 +1,55 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\DependencyInjection\Compiler;
+
+
+use App\Repository\ContextRepository\UserContextRepository;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Annotation\ServiceCall;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\CompilerPassServiceAnnotationTrait;
+use SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils\ReflectionCacheTrait;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
+use Symfony\Component\DependencyInjection\Reference;
+
+class ServiceCallPass implements CompilerPassInterface
+{
+    use ReflectionCacheTrait;
+    use CompilerPassServiceAnnotationTrait;
+
+    public function process(ContainerBuilder $container)
+    {
+        foreach ($container->getDefinitions() as $serviceId => $definition) {
+            if (false === $this->definitionHasValidClass($definition)) {
+                continue;
+            }
+
+            $rc = $this->getClassReflection($definition->getClass());
+
+            foreach ($rc->getMethods() as $method) {
+                if ($annotation = $this->annotationReader->getMethodAnnotation($method, ServiceCall::class)) {
+                    $parameters = [];
+                    foreach ($method->getParameters() as $parameter) {
+                        if (null === $parameter->getClass()) {
+                            $value = $parameter->getDefaultValue();
+                            \settype($value, $parameter->getType());
+                        } else {
+                            $value = $parameter->getClass()->getName();
+                        }
+
+                        try {
+                            $container->findDefinition($value);
+                            $value = new Reference($value);
+                        } catch (ServiceNotFoundException $serviceNotFoundException) {
+                        }
+
+                        $parameters[$parameter->getPosition()] = $value;
+                    }
+
+                    $definition->addMethodCall($method->getName(), $parameters);
+                }
+            }
+        }
+    }
+}

Exception/InvalidCloneConfigurationException.php

@@ -0,0 +1,12 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\Exception;
+
+
+use Exception;
+
+class InvalidCloneConfigurationException extends Exception
+{
+
+}

Utils/InstanceOfInjectionTrait.php

@@ -0,0 +1,64 @@
+<?php
+
+
+namespace SimonMarx\Symfony\Bundles\ServiceAnnotations\Utils;
+
+
+use App\Serializer\Normalizer\DateTimeNormalizer;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+
+trait InstanceOfInjectionTrait
+{
+    private function checkDefinitionHasInstanceOfConfigurations(ContainerBuilder $container, Definition $definition)
+    {
+        $instanceOfConditionals = $definition->getInstanceofConditionals();
+        $autoconfiguredInstanceof = $definition->isAutoconfigured() ? $container->getAutoconfiguredInstanceof() : [];
+
+        if (\count($autoconfiguredInstanceof) === 0 && \count($instanceOfConditionals) === 0) {
+            return false;
+        }
+
+        $instanceOfClasses = \array_keys($autoconfiguredInstanceof);
+
+        if ($definition->getClass() === DateTimeNormalizer::class) {
+            foreach ($instanceOfClasses as $instanceOfClass) {
+                $rc = $container->getReflectionClass($definition->getClass());
+
+                if (
+                    (\class_exists($instanceOfClass) && $rc->isSubclassOf($instanceOfClass))
+                    || (\interface_exists($instanceOfClass) && $rc->implementsInterface($instanceOfClass))
+                ) {
+                    return false === $definition instanceof ChildDefinition;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private function mergeConditionals(array $autoconfiguredInstanceof, array $instanceofConditionals, ContainerBuilder $container): array
+    {
+        // make each value an array of ChildDefinition
+        $conditionals = array_map(function ($childDef) {
+            return [$childDef];
+        }, $autoconfiguredInstanceof);
+
+        foreach ($instanceofConditionals as $interface => $instanceofDef) {
+            // make sure the interface/class exists (but don't validate automaticInstanceofConditionals)
+            if (!$container->getReflectionClass($interface)) {
+                throw new RuntimeException(sprintf('"%s" is set as an "instanceof" conditional, but it does not exist.', $interface));
+            }
+
+            if (!isset($autoconfiguredInstanceof[$interface])) {
+                $conditionals[$interface] = [];
+            }
+
+            $conditionals[$interface][] = $instanceofDef;
+        }
+
+        return $conditionals;
+    }
+}