ExtensionCompilerPass::addExtension() - Code Metrics - sonata-project/SonataAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

ExtensionCompilerPass::addExtension() A
last analyzed 2020-08-22 14:45 UTC

↳ Parent: ExtensionCompilerPass

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.8333
c	0
b	0
f	0
cc	2
nc	2
nop	4

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\AdminBundle\DependencyInjection\Compiler;

use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;

/**
 * @author Thomas Rabaix <[email protected]>
 */
final class ExtensionCompilerPass implements CompilerPassInterface
{
    public function process(ContainerBuilder $container): void
    {
        $universalExtensions = [];
        $targets = [];

        foreach ($container->findTaggedServiceIds('sonata.admin.extension') as $id => $tags) {
            foreach ($tags as $attributes) {
                $target = false;

                if (isset($attributes['target'])) {
                    $target = $attributes['target'];
                }

                if (isset($attributes['global']) && $attributes['global']) {
                    $universalExtensions[$id] = $attributes;
                }

                if (!$target || !$container->hasDefinition($target)) {
                    continue;
                }

                $this->addExtension($targets, $target, $id, $attributes);
            }
        }

        $extensionConfig = $container->getParameter('sonata.admin.extension.map');
        $extensionMap = $this->flattenExtensionConfiguration($extensionConfig);

        foreach ($container->findTaggedServiceIds('sonata.admin') as $id => $attributes) {
            $admin = $container->getDefinition($id);

            if (!isset($targets[$id])) {
                $targets[$id] = new \SplPriorityQueue();
            }

            foreach ($universalExtensions as $extension => $extensionAttributes) {
                $this->addExtension($targets, $id, $extension, $extensionAttributes);
            }

            $extensions = $this->getExtensionsForAdmin($id, $admin, $container, $extensionMap);

            foreach ($extensions as $extension => $attributes) {
                if (!$container->has($extension)) {
                    throw new \InvalidArgumentException(sprintf(
                        'Unable to find extension service for id %s',
                        $extension
                    ));
                }

                $this->addExtension($targets, $id, $extension, $attributes);
            }
        }

        foreach ($targets as $target => $extensions) {
            $extensions = iterator_to_array($extensions);
            krsort($extensions);
            $admin = $container->getDefinition($target);

            foreach (array_values($extensions) as $extension) {
                $admin->addMethodCall('addExtension', [$extension]);
            }
        }
    }

    /**
     * @param string $id
     *
     * @return array
     */
    private function getExtensionsForAdmin($id, Definition $admin, ContainerBuilder $container, array $extensionMap)
    {
        $extensions = [];
        $classReflection = $subjectReflection = null;

        $excludes = $extensionMap['excludes'];
        unset($extensionMap['excludes']);

        foreach ($extensionMap as $type => $subjects) {
            foreach ($subjects as $subject => $extensionList) {
                if ('admins' === $type) {
                    if ($id === $subject) {
                        $extensions = array_merge($extensions, $extensionList);
                    }
                } else {
                    $class = $this->getManagedClass($admin, $container);
                    if (!class_exists($class)) {
                        continue;
                    }
                    $classReflection = new \ReflectionClass($class);
                    $subjectReflection = new \ReflectionClass($subject);
                }

                if ('instanceof' === $type) {
                    if ($subjectReflection->getName() === $classReflection->getName() || $classReflection->isSubclassOf($subject)) {
                        $extensions = array_merge($extensions, $extensionList);
                    }
                }

                if ('implements' === $type) {
                    if ($classReflection->implementsInterface($subject)) {
                        $extensions = array_merge($extensions, $extensionList);
                    }
                }

                if ('extends' === $type) {
                    if ($classReflection->isSubclassOf($subject)) {
                        $extensions = array_merge($extensions, $extensionList);
                    }
                }

                if ('uses' === $type) {
                    if ($this->hasTrait($classReflection, $subject)) {
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                        $extensions = array_merge($extensions, $extensionList);
                    }
                }
            }
        }

        if (isset($excludes[$id])) {
            $extensions = array_diff_key($extensions, $excludes[$id]);
        }

        return $extensions;
    }

    /**
     * Resolves the class argument of the admin to an actual class (in case of %parameter%).
     *
     * @return string
     */
    private function getManagedClass(Definition $admin, ContainerBuilder $container)
    {
        return $container->getParameterBag()->resolveValue($admin->getArgument(1));
    }

    /**
     * @return array an array with the following structure.
     *
     * [
     *     'excludes'   => ['<admin_id>'  => ['<extension_id>' => ['priority' => <int>]]],
     *     'admins'     => ['<admin_id>'  => ['<extension_id>' => ['priority' => <int>]]],
     *     'implements' => ['<interface>' => ['<extension_id>' => ['priority' => <int>]]],
     *     'extends'    => ['<class>'     => ['<extension_id>' => ['priority' => <int>]]],
     *     'instanceof' => ['<class>'     => ['<extension_id>' => ['priority' => <int>]]],
     *     'uses'       => ['<trait>'     => ['<extension_id>' => ['priority' => <int>]]],
     * ]
     */
    private function flattenExtensionConfiguration(array $config)
    {
        $extensionMap = [
            'excludes' => [],
            'admins' => [],
            'implements' => [],
            'extends' => [],
            'instanceof' => [],
            'uses' => [],
        ];

        foreach ($config as $extension => $options) {
            $optionsMap = array_intersect_key($options, $extensionMap);

            foreach ($optionsMap as $key => $value) {
                foreach ($value as $source) {
                    if (!isset($extensionMap[$key][$source])) {
                        $extensionMap[$key][$source] = [];
                    }
                    $extensionMap[$key][$source][$extension]['priority'] = $options['priority'];
                }
            }
        }

        return $extensionMap;
    }

    /**
     * @return bool
     */
    private function hasTrait(\ReflectionClass $class, $traitName)
    {
        if (\in_array($traitName, $class->getTraitNames(), true)) {
            return true;
        }

        if (!$parentClass = $class->getParentClass()) {
            return false;
        }

        return $this->hasTrait($parentClass, $traitName);
    }

    /**
     * Add extension configuration to the targets array.
     */
    private function addExtension(
        array &$targets,
        string $target,
        string $extension,
        array $attributes
    ): void {
        if (!isset($targets[$target])) {
            $targets[$target] = new \SplPriorityQueue();
        }

        $priority = $attributes['priority'] ?? 0;
        $targets[$target]->insert(new Reference($extension), $priority);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\AdminBundle\DependencyInjection\Compiler;
15
16			use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
17			use Symfony\Component\DependencyInjection\ContainerBuilder;
18			use Symfony\Component\DependencyInjection\Definition;
19			use Symfony\Component\DependencyInjection\Reference;
20
21			/**
22			* @author Thomas Rabaix <[email protected]>
23			*/
24			final class ExtensionCompilerPass implements CompilerPassInterface
25			{
26			public function process(ContainerBuilder $container): void
27			{
28			$universalExtensions = [];
29			$targets = [];
30
31			foreach ($container->findTaggedServiceIds('sonata.admin.extension') as $id => $tags) {
32			foreach ($tags as $attributes) {
33			$target = false;
34
35			if (isset($attributes['target'])) {
36			$target = $attributes['target'];
37			}
38
39			if (isset($attributes['global']) && $attributes['global']) {
40			$universalExtensions[$id] = $attributes;
41			}
42
43			if (!$target \|\| !$container->hasDefinition($target)) {
44			continue;
45			}
46
47			$this->addExtension($targets, $target, $id, $attributes);
48			}
49			}
50
51			$extensionConfig = $container->getParameter('sonata.admin.extension.map');
52			$extensionMap = $this->flattenExtensionConfiguration($extensionConfig);
53
54			foreach ($container->findTaggedServiceIds('sonata.admin') as $id => $attributes) {
55			$admin = $container->getDefinition($id);
56
57			if (!isset($targets[$id])) {
58			$targets[$id] = new \SplPriorityQueue();
59			}
60
61			foreach ($universalExtensions as $extension => $extensionAttributes) {
62			$this->addExtension($targets, $id, $extension, $extensionAttributes);
63			}
64
65			$extensions = $this->getExtensionsForAdmin($id, $admin, $container, $extensionMap);
66
67			foreach ($extensions as $extension => $attributes) {
68			if (!$container->has($extension)) {
69			throw new \InvalidArgumentException(sprintf(
70			'Unable to find extension service for id %s',
71			$extension
72			));
73			}
74
75			$this->addExtension($targets, $id, $extension, $attributes);
76			}
77			}
78
79			foreach ($targets as $target => $extensions) {
80			$extensions = iterator_to_array($extensions);
81			krsort($extensions);
82			$admin = $container->getDefinition($target);
83
84			foreach (array_values($extensions) as $extension) {
85			$admin->addMethodCall('addExtension', [$extension]);
86			}
87			}
88			}
89
90			/**
91			* @param string $id
92			*
93			* @return array
94			*/
95			private function getExtensionsForAdmin($id, Definition $admin, ContainerBuilder $container, array $extensionMap)
96			{
97			$extensions = [];
98			$classReflection = $subjectReflection = null;
99
100			$excludes = $extensionMap['excludes'];
101			unset($extensionMap['excludes']);
102
103			foreach ($extensionMap as $type => $subjects) {
104			foreach ($subjects as $subject => $extensionList) {
105			if ('admins' === $type) {
106			if ($id === $subject) {
107			$extensions = array_merge($extensions, $extensionList);
108			}
109			} else {
110			$class = $this->getManagedClass($admin, $container);
111			if (!class_exists($class)) {
112			continue;
113			}
114			$classReflection = new \ReflectionClass($class);
115			$subjectReflection = new \ReflectionClass($subject);
116			}
117
118			if ('instanceof' === $type) {
119			if ($subjectReflection->getName() === $classReflection->getName() \|\| $classReflection->isSubclassOf($subject)) {
120			$extensions = array_merge($extensions, $extensionList);
121			}
122			}
123
124			if ('implements' === $type) {
125			if ($classReflection->implementsInterface($subject)) {
126			$extensions = array_merge($extensions, $extensionList);
127			}
128			}
129
130			if ('extends' === $type) {
131			if ($classReflection->isSubclassOf($subject)) {
132			$extensions = array_merge($extensions, $extensionList);
133			}
134			}
135
136			if ('uses' === $type) {
137			if ($this->hasTrait($classReflection, $subject)) {
			0 ignored issues – show Bug introduced 2017-05-15 14:24 UTC by Report Bug Copy Issue Report It seems like `$classReflection` defined by `$subjectReflection = null` on line `98` can be `null`; however, `Sonata\AdminBundle\Depen...ompilerPass::hasTrait()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
138			$extensions = array_merge($extensions, $extensionList);
139			}
140			}
141			}
142			}
143
144			if (isset($excludes[$id])) {
145			$extensions = array_diff_key($extensions, $excludes[$id]);
146			}
147
148			return $extensions;
149			}
150
151			/**
152			* Resolves the class argument of the admin to an actual class (in case of %parameter%).
153			*
154			* @return string
155			*/
156			private function getManagedClass(Definition $admin, ContainerBuilder $container)
157			{
158			return $container->getParameterBag()->resolveValue($admin->getArgument(1));
159			}
160
161			/**
162			* @return array an array with the following structure.
163			*
164			* [
165			* 'excludes' => ['<admin_id>' => ['<extension_id>' => ['priority' => <int>]]],
166			* 'admins' => ['<admin_id>' => ['<extension_id>' => ['priority' => <int>]]],
167			* 'implements' => ['<interface>' => ['<extension_id>' => ['priority' => <int>]]],
168			* 'extends' => ['<class>' => ['<extension_id>' => ['priority' => <int>]]],
169			* 'instanceof' => ['<class>' => ['<extension_id>' => ['priority' => <int>]]],
170			* 'uses' => ['<trait>' => ['<extension_id>' => ['priority' => <int>]]],
171			* ]
172			*/
173			private function flattenExtensionConfiguration(array $config)
174			{
175			$extensionMap = [
176			'excludes' => [],
177			'admins' => [],
178			'implements' => [],
179			'extends' => [],
180			'instanceof' => [],
181			'uses' => [],
182			];
183
184			foreach ($config as $extension => $options) {
185			$optionsMap = array_intersect_key($options, $extensionMap);
186
187			foreach ($optionsMap as $key => $value) {
188			foreach ($value as $source) {
189			if (!isset($extensionMap[$key][$source])) {
190			$extensionMap[$key][$source] = [];
191			}
192			$extensionMap[$key][$source][$extension]['priority'] = $options['priority'];
193			}
194			}
195			}
196
197			return $extensionMap;
198			}
199
200			/**
201			* @return bool
202			*/
203			private function hasTrait(\ReflectionClass $class, $traitName)
204			{
205			if (\in_array($traitName, $class->getTraitNames(), true)) {
206			return true;
207			}
208
209			if (!$parentClass = $class->getParentClass()) {
210			return false;
211			}
212
213			return $this->hasTrait($parentClass, $traitName);
214			}
215
216			/**
217			* Add extension configuration to the targets array.
218			*/
219			private function addExtension(
220			array &$targets,
221			string $target,
222			string $extension,
223			array $attributes
224			): void {
225			if (!isset($targets[$target])) {
226			$targets[$target] = new \SplPriorityQueue();
227			}
228
229			$priority = $attributes['priority'] ?? 0;
230			$targets[$target]->insert(new Reference($extension), $priority);
231			}
232			}
233

sonata-project / SonataAdminBundle

ExtensionCompilerPass::addExtension() A last analyzed 2020-08-22 14:45 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ExtensionCompilerPass::addExtension() A
last analyzed 2020-08-22 14:45 UTC