vendor/sonata-project/admin-bundle/src/DependencyInjection/Compiler/ExtensionCompilerPass.php line 138

  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of the Sonata Project package.
  7.  *
  8.  * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Sonata\AdminBundle\DependencyInjection\Compiler;
  16. use Sonata\AdminBundle\DependencyInjection\Admin\TaggedAdminInterface;
  17. use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
  18. use Symfony\Component\DependencyInjection\ContainerBuilder;
  19. use Symfony\Component\DependencyInjection\Definition;
  20. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  21. use Symfony\Component\DependencyInjection\Reference;
  23. /**
  24.  * @internal
  25.  *
  26.  * @phpstan-type ExtensionMap = array<string, array{
  27.  *     global: bool,
  28.  *     excludes: array<string, string>,
  29.  *     admins: array<string, string>,
  30.  *     implements: array<class-string, string>,
  31.  *     extends: array<class-string, string>,
  32.  *     instanceof: array<class-string, string>,
  33.  *     uses: array<class-string, string>,
  34.  *     admin_implements: array<class-string, string>,
  35.  *     admin_extends: array<class-string, string>,
  36.  *     admin_instanceof: array<class-string, string>,
  37.  *     admin_uses: array<class-string, string>,
  38.  *     priority: int,
  39.  * }>
  40.  * @phpstan-type FlattenExtensionMap = array{
  41.  *     global: array<string, array<string, array{priority: int}>>,
  42.  *     excludes: array<string, array<string, array{priority: int}>>,
  43.  *     admins: array<string, array<string, array{priority: int}>>,
  44.  *     implements: array<string, array<class-string, array{priority: int}>>,
  45.  *     extends: array<string, array<class-string, array{priority: int}>>,
  46.  *     instanceof: array<string, array<class-string, array{priority: int}>>,
  47.  *     uses: array<string, array<class-string, array{priority: int}>>,
  48.  *     admin_implements: array<string, array<class-string, array{priority: int}>>,
  49.  *     admin_extends: array<string, array<class-string, array{priority: int}>>,
  50.  *     admin_instanceof: array<string, array<class-string, array{priority: int}>>,
  51.  *     admin_uses: array<string, array<class-string, array{priority: int}>>,
  52.  * }
  53.  *
  54.  * @author Thomas Rabaix <thomas.rabaix@sonata-project.org>
  55.  */
  56. final class ExtensionCompilerPass implements CompilerPassInterface
  57. {
  58.     public function process(ContainerBuilder $container): void
  59.     {
  60.         $universalExtensions = [];
  61.         $targets = [];
  63.         foreach ($container->findTaggedServiceIds('sonata.admin.extension') as $id => $tags) {
  64.             $adminExtension = $container->getDefinition($id);
  66.             // Trim possible parameter delimiters ("%") from the class name.
  67.             $adminExtensionClass = trim($adminExtension->getClass() ?? '', '%');
  68.             if (!class_exists($adminExtensionClass, false) && $container->hasParameter($adminExtensionClass)) {
  69.                 $adminExtensionClass = $container->getParameter($adminExtensionClass);
  70.                 \assert(\is_string($adminExtensionClass));
  71.             }
  72.             \assert(class_exists($adminExtensionClass));
  74.             foreach ($tags as $attributes) {
  75.                 $target = false;
  77.                 if (isset($attributes['target'])) {
  78.                     $target = $attributes['target'];
  79.                     unset($attributes['target']);
  80.                 }
  82.                 if (isset($attributes['global'])) {
  83.                     if ($attributes['global']) {
  84.                         $attributes['global'] = $adminExtensionClass;
  85.                     } else {
  86.                         unset($attributes['global']);
  87.                     }
  88.                 }
  89.                 $universalExtensions[$id][] = $attributes;
  91.                 if (!$target || !$container->hasDefinition($target)) {
  92.                     continue;
  93.                 }
  95.                 $this->addExtension($targets, $target, $id, $attributes);
  96.             }
  97.         }
  99.         /**
  100.          * @phpstan-var ExtensionMap $extensionConfig
  101.          */
  102.         $extensionConfig = $container->getParameter('sonata.admin.extension.map');
  103.         $extensionMap = $this->flattenExtensionConfiguration($extensionConfig);
  105.         foreach ($container->findTaggedServiceIds(TaggedAdminInterface::ADMIN_TAG) as $id => $tags) {
  106.             $admin = $container->getDefinition($id);
  108.             // Trim possible parameter delimiters ("%") from the class name.
  109.             $adminClass = trim($admin->getClass() ?? '', '%');
  110.             if (!class_exists($adminClass, false) && $container->hasParameter($adminClass)) {
  111.                 $adminClass = $container->getParameter($adminClass);
  112.                 \assert(\is_string($adminClass));
  113.             }
  114.             \assert(class_exists($adminClass));
  116.             if (!isset($targets[$id])) {
  117.                 $targets[$id] = new \SplPriorityQueue();
  118.             }
  120.             // NEXT_MAJOR: Remove this line.
  121.             $defaultModelClass = $admin->getArguments()[1] ?? null;
  122.             foreach ($tags as $attributes) {
  123.                 // NEXT_MAJOR: Remove the fallback to $defaultModelClass and use null instead.
  124.                 $modelClass = $attributes['model_class'] ?? $defaultModelClass;
  125.                 if (null === $modelClass) {
  126.                     throw new InvalidArgumentException(sprintf('Missing tag attribute "model_class" on service "%s".', $id));
  127.                 }
  129.                 $class = $container->getParameterBag()->resolveValue($modelClass);
  130.                 if (!\is_string($class)) {
  131.                     throw new \TypeError(sprintf(
  132.                         'Tag attribute "model_class" for service "%s" must be of type string, %s given.',
  133.                         $id,
  134.                         get_debug_type($class)
  135.                     ));
  136.                 }
  138.                 if (!class_exists($class)) {
  139.                     continue;
  140.                 }
  142.                 foreach ($universalExtensions as $extension => $extensionsAttributes) {
  143.                     foreach ($extensionsAttributes as $extensionAttributes) {
  144.                         if (isset($extensionAttributes['excludes'][$id])) {
  145.                             continue;
  146.                         }
  148.                         foreach ($extensionAttributes as $type => $subject) {
  149.                             if ($this->shouldApplyExtension($type, $subject, $class, $adminClass)) {
  150.                                 $this->addExtension($targets, $id, $extension, $extensionAttributes);
  151.                                 break;
  152.                             }
  153.                         }
  154.                     }
  155.                 }
  156.             }
  158.             $extensions = $this->getExtensionsForAdmin($id, $tags, $admin, $container, $extensionMap);
  160.             foreach ($extensions as $extension => $attributes) {
  161.                 if (!$container->has($extension)) {
  162.                     throw new \InvalidArgumentException(sprintf(
  163.                         'Unable to find extension service for id %s',
  164.                         $extension
  165.                     ));
  166.                 }
  168.                 $this->addExtension($targets, $id, $extension, $attributes);
  169.             }
  170.         }
  172.         foreach ($targets as $target => $extensions) {
  173.             $extensions = iterator_to_array($extensions);
  174.             krsort($extensions);
  175.             $admin = $container->getDefinition($target);
  177.             foreach (array_values($extensions) as $extension) {
  178.                 $admin->addMethodCall('addExtension', [$extension]);
  179.             }
  180.         }
  181.     }
  183.     /**
  184.      * @param array<string, mixed>                                              $tags
  185.      * @param array<string, array<string, array<string, array<string, mixed>>>> $extensionMap
  186.      *
  187.      * @return array<string, array<string, mixed>>
  188.      *
  189.      * @phpstan-param FlattenExtensionMap $extensionMap
  190.      */
  191.     private function getExtensionsForAdmin(string $id, array $tags, Definition $admin, ContainerBuilder $container, array $extensionMap): array
  192.     {
  193.         // Trim possible parameter delimiters ("%") from the class name.
  194.         $adminClass = trim($admin->getClass() ?? '', '%');
  195.         if (!class_exists($adminClass, false) && $container->hasParameter($adminClass)) {
  196.             $adminClass = $container->getParameter($adminClass);
  197.             \assert(\is_string($adminClass));
  198.         }
  199.         \assert(class_exists($adminClass));
  201.         $extensions = [];
  203.         $excludes = $extensionMap['excludes'];
  204.         unset($extensionMap['excludes']);
  206.         foreach ($extensionMap as $type => $subjects) {
  207.             foreach ($subjects as $subject => $extensionList) {
  208.                 if ('admins' === $type) {
  209.                     if ($id === $subject) {
  210.                         $extensions = array_merge($extensions, $extensionList);
  211.                     }
  213.                     continue;
  214.                 }
  216.                 // NEXT_MAJOR: Remove this line.
  217.                 $defaultModelClass = $admin->getArguments()[1] ?? null;
  218.                 foreach ($tags as $attributes) {
  219.                     // NEXT_MAJOR: Remove the fallback to $defaultModelClass and use null instead.
  220.                     $modelClass = $attributes['model_class'] ?? $defaultModelClass;
  221.                     if (null === $modelClass) {
  222.                         throw new InvalidArgumentException(sprintf('Missing tag attribute "model_class" on service "%s".', $id));
  223.                     }
  225.                     $class = $container->getParameterBag()->resolveValue($modelClass);
  226.                     if (!\is_string($class)) {
  227.                         throw new \TypeError(sprintf(
  228.                             'Tag attribute "model_class" for service "%s" must be of type string, %s given.',
  229.                             $id,
  230.                             get_debug_type($class)
  231.                         ));
  232.                     }
  234.                     if (!class_exists($class)) {
  235.                         continue;
  236.                     }
  238.                     if ($this->shouldApplyExtension($type, $subject, $class, $adminClass)) {
  239.                         $extensions = array_merge($extensions, $extensionList);
  240.                     }
  241.                 }
  242.             }
  243.         }
  245.         if (isset($excludes[$id])) {
  246.             $extensions = array_diff_key($extensions, $excludes[$id]);
  247.         }
  249.         return $extensions;
  250.     }
  252.     /**
  253.      * @param array<string, array<string, array<string, string>|int|bool>> $config
  254.      *
  255.      * @return array<string, array<string, array<string, array<string, int>>>> an array with the following structure
  256.      *
  257.      * @phpstan-param ExtensionMap $config
  258.      * @phpstan-return FlattenExtensionMap
  259.      */
  260.     private function flattenExtensionConfiguration(array $config): array
  261.     {
  262.         /** @phpstan-var FlattenExtensionMap $extensionMap */
  263.         $extensionMap = [
  264.             'global' => [],
  265.             'excludes' => [],
  266.             'admins' => [],
  267.             'implements' => [],
  268.             'extends' => [],
  269.             'instanceof' => [],
  270.             'uses' => [],
  271.             'admin_implements' => [],
  272.             'admin_extends' => [],
  273.             'admin_instanceof' => [],
  274.             'admin_uses' => [],
  275.         ];
  277.         foreach ($config as $extension => $options) {
  278.             if (true === $options['global']) {
  279.                 $options['global'] = [$extension];
  280.             } else {
  281.                 $options['global'] = [];
  282.             }
  284.             /**
  285.              * @phpstan-var array{
  286.              *     global: array<string, string>,
  287.              *     excludes: array<string, string>,
  288.              *     admins: array<string, string>,
  289.              *     implements: array<class-string, string>,
  290.              *     extends: array<class-string, string>,
  291.              *     instanceof: array<class-string, string>,
  292.              *     uses: array<class-string, string>,
  293.              *     admin_implements: array<class-string, string>,
  294.              *     admin_extends: array<class-string, string>,
  295.              *     admin_instanceof: array<class-string, string>,
  296.              *     admin_uses: array<class-string, string>,
  297.              * } $optionsMap
  298.              */
  299.             $optionsMap = array_intersect_key($options, $extensionMap);
  301.             foreach ($extensionMap as $key => &$value) {
  302.                 foreach ($optionsMap[$key] as $source) {
  303.                     $value[$source][$extension]['priority'] = $options['priority'];
  304.                 }
  305.             }
  306.         }
  308.         return $extensionMap;
  309.     }
  311.     /**
  312.      * @param \ReflectionClass<object> $class
  313.      */
  314.     private function hasTrait(\ReflectionClass $class, string $traitName): bool
  315.     {
  316.         if (\in_array($traitName, $class->getTraitNames(), true)) {
  317.             return true;
  318.         }
  320.         $parentClass = $class->getParentClass();
  321.         if (false === $parentClass) {
  322.             return false;
  323.         }
  325.         return $this->hasTrait($parentClass, $traitName);
  326.     }
  328.     /**
  329.      * @phpstan-param class-string $class
  330.      * @phpstan-param class-string $adminClass
  331.      */
  332.     private function shouldApplyExtension(string $type, mixed $subject, string $class, string $adminClass): bool
  333.     {
  334.         $classReflection = new \ReflectionClass($class);
  335.         $adminClassReflection = new \ReflectionClass($adminClass);
  337.         switch ($type) {
  338.             case 'global':
  339.                 return true;
  340.             case 'instanceof':
  341.                 if (!\is_string($subject) || !class_exists($subject)) {
  342.                     return false;
  343.                 }
  345.                 $subjectReflection = new \ReflectionClass($subject);
  347.                 return $classReflection->isSubclassOf($subject) || $subjectReflection->getName() === $classReflection->getName();
  348.             case 'implements':
  349.                 return \is_string($subject) && interface_exists($subject) && $classReflection->implementsInterface($subject);
  350.             case 'extends':
  351.                 return \is_string($subject) && class_exists($subject) && $classReflection->isSubclassOf($subject);
  352.             case 'uses':
  353.                 return \is_string($subject) && trait_exists($subject) && $this->hasTrait($classReflection, $subject);
  354.             case 'admin_instanceof':
  355.                 if (!\is_string($subject) || !class_exists($subject)) {
  356.                     return false;
  357.                 }
  359.                 $subjectReflection = new \ReflectionClass($subject);
  361.                 return $adminClassReflection->isSubclassOf($subject) || $subjectReflection->getName() === $adminClassReflection->getName();
  362.             case 'admin_implements':
  363.                 return \is_string($subject) && interface_exists($subject) && $adminClassReflection->implementsInterface($subject);
  364.             case 'admin_extends':
  365.                 return \is_string($subject) && class_exists($subject) && $adminClassReflection->isSubclassOf($subject);
  366.             case 'admin_uses':
  367.                 return \is_string($subject) && trait_exists($subject) && $this->hasTrait($adminClassReflection, $subject);
  368.             default:
  369.                 return false;
  370.         }
  371.     }
  373.     /**
  374.      * Add extension configuration to the targets array.
  375.      *
  376.      * @param array<string, \SplPriorityQueue<int, Reference>> $targets
  377.      * @param array<string, mixed>                             $attributes
  378.      */
  379.     private function addExtension(
  380.         array &$targets,
  381.         string $target,
  382.         string $extension,
  383.         array $attributes
  384.     ): void {
  385.         if (!isset($targets[$target])) {
  386.             /** @phpstan-var \SplPriorityQueue<int, Reference> $queue */
  387.             $queue = new \SplPriorityQueue();
  388.             $targets[$target] = $queue;
  389.         }
  391.         $priority = $attributes['priority'] ?? 0;
  392.         $targets[$target]->insert(new Reference($extension), $priority);
  393.     }
  394. }