AddDependencyCallsCompilerPass::process() - Code Metrics - Inspection of "Manual merge" - sonata-project/SonataAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#6097)

by Javier

created 2020-05-22 03:42 UTC

AddDependencyCallsCompilerPass::process() F

↳ Parent: AddDependencyCallsCompilerPass

Complexity

Conditions	36
Paths	19255

Size

Total Lines

180

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	180
rs	0
c	0
b	0
f	0
cc	36
nc	19255
nop	1

How to fix Long Method Complexity

<?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 Doctrine\Inflector\InflectorFactory;
use Sonata\AdminBundle\Controller\CRUDController;
use Sonata\AdminBundle\Datagrid\Pager;
use Sonata\AdminBundle\Templating\TemplateRegistry;
use Symfony\Component\DependencyInjection\ChildDefinition;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;

/**
 * Add all dependencies to the Admin class, this avoid to write too many lines
 * in the configuration files.
 *
 * @final since sonata-project/admin-bundle 3.52
 *
 * @author Thomas Rabaix <[email protected]>
 */
final class AddDependencyCallsCompilerPass implements CompilerPassInterface
{
    public function process(ContainerBuilder $container): void
    {
        // check if translator service exist
        if (!$container->has('translator')) {
            throw new \RuntimeException('The "translator" service is not yet enabled.
                It\'s required by SonataAdmin to display all labels properly.

                To learn how to enable the translator service please visit:
                http://symfony.com/doc/current/translation.html#configuration
             ');
        }

        $parameterBag = $container->getParameterBag();
        $groupDefaults = $admins = $classes = [];

        $pool = $container->getDefinition('sonata.admin.pool');

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

                // Temporary fix until we can support service locators
                $definition->setPublic(true);

                if ($definition instanceof ChildDefinition) {
                    $parentDefinition = $container->getDefinition($definition->getParent());
                }

                $this->replaceDefaultArguments([
                    0 => $id,
                    2 => CRUDController::class,
                ], $definition, $parentDefinition);
                $this->applyConfigurationFromAttribute($definition, $attributes);
                $this->applyDefaults($container, $id, $attributes);

                $arguments = $parentDefinition ?
                    array_merge($parentDefinition->getArguments(), $definition->getArguments()) :
                    $definition->getArguments();

                $admins[] = $id;

                if (!isset($classes[$arguments[1]])) {
                    $classes[$arguments[1]] = [];
                }

                $classes[$arguments[1]][] = $id;

                $showInDashboard = (bool) (isset($attributes['show_in_dashboard']) ? $parameterBag->resolveValue($attributes['show_in_dashboard']) : true);
                if (!$showInDashboard) {
                    continue;
                }

                $resolvedGroupName = isset($attributes['group']) ?
                    $parameterBag->resolveValue($attributes['group']) :
                    $container->getParameter('sonata.admin.configuration.default_group');
                $labelCatalogue = $attributes['label_catalogue'] ??
                    $container->getParameter('sonata.admin.configuration.default_label_catalogue');
                $icon = $attributes['icon'] ??
                    $container->getParameter('sonata.admin.configuration.default_icon');
                $onTop = $attributes['on_top'] ?? false;
                $keepOpen = $attributes['keep_open'] ?? false;

                if (!isset($groupDefaults[$resolvedGroupName])) {
                    $groupDefaults[$resolvedGroupName] = [
                        'label' => $resolvedGroupName,
                        'label_catalogue' => $labelCatalogue,
                        'icon' => $icon,
                        'roles' => [],
                        'on_top' => false,
                        'keep_open' => false,
                    ];
                }

                $groupDefaults[$resolvedGroupName]['items'][] = [
                    'admin' => $id,
                    'label' => !empty($attributes['label']) ? $attributes['label'] : '',
                    'route' => '',
                    'route_params' => [],
                    'route_absolute' => false,
                ];

                if (isset($groupDefaults[$resolvedGroupName]['on_top']) && $groupDefaults[$resolvedGroupName]['on_top']
                    || $onTop && (\count($groupDefaults[$resolvedGroupName]['items']) > 1)) {
                    throw new \RuntimeException('You can\'t use "on_top" option with multiple same name groups.');
                }
                $groupDefaults[$resolvedGroupName]['on_top'] = $onTop;

                $groupDefaults[$resolvedGroupName]['keep_open'] = $keepOpen;
            }
        }

        $dashboardGroupsSettings = $container->getParameter('sonata.admin.configuration.dashboard_groups');
        if (!empty($dashboardGroupsSettings)) {
            $groups = $dashboardGroupsSettings;

            foreach ($dashboardGroupsSettings as $groupName => $group) {
                $resolvedGroupName = $parameterBag->resolveValue($groupName);
                if (!isset($groupDefaults[$resolvedGroupName])) {
                    $groupDefaults[$resolvedGroupName] = [
                        'items' => [],
                        'label' => $resolvedGroupName,
                        'roles' => [],
                        'on_top' => false,
                        'keep_open' => false,
                    ];
                }

                if (empty($group['items'])) {
                    $groups[$resolvedGroupName]['items'] = $groupDefaults[$resolvedGroupName]['items'];
                }

                if (empty($group['label'])) {
                    $groups[$resolvedGroupName]['label'] = $groupDefaults[$resolvedGroupName]['label'];
                }

                if (empty($group['label_catalogue'])) {
                    $groups[$resolvedGroupName]['label_catalogue'] = 'SonataAdminBundle';
                }

                if (empty($group['icon'])) {
                    $groups[$resolvedGroupName]['icon'] = $groupDefaults[$resolvedGroupName]['icon'];
                }

                if (!empty($group['item_adds'])) {
                    $groups[$resolvedGroupName]['items'] = array_merge($groups[$resolvedGroupName]['items'], $group['item_adds']);
                }

                if (empty($group['roles'])) {
                    $groups[$resolvedGroupName]['roles'] = $groupDefaults[$resolvedGroupName]['roles'];
                }

                if (isset($groups[$resolvedGroupName]['on_top']) && !empty($group['on_top']) && $group['on_top']
                    && (\count($groups[$resolvedGroupName]['items']) > 1)) {
                    throw new \RuntimeException('You can\'t use "on_top" option with multiple same name groups.');
                }
                if (empty($group['on_top'])) {
                    $groups[$resolvedGroupName]['on_top'] = $groupDefaults[$resolvedGroupName]['on_top'];
                }

                if (empty($group['keep_open'])) {
                    $groups[$resolvedGroupName]['keep_open'] = $groupDefaults[$resolvedGroupName]['keep_open'];
                }
            }
        } elseif ($container->getParameter('sonata.admin.configuration.sort_admins')) {
            $groups = $groupDefaults;

            $elementSort = static function (&$element): void {
                usort(
                    $element['items'],
                    static function ($a, $b) {
                        $a = !empty($a['label']) ? $a['label'] : $a['admin'];
                        $b = !empty($b['label']) ? $b['label'] : $b['admin'];

                        if ($a === $b) {
                            return 0;
                        }

                        return $a < $b ? -1 : 1;
                    }
                );
            };

            /*
             * 1) sort the groups by their index
             * 2) sort the elements within each group by label/admin
             */
            ksort($groups);
            array_walk($groups, $elementSort);
        } else {
            $groups = $groupDefaults;
        }

        $pool->addMethodCall('setAdminServiceIds', [$admins]);
        $pool->addMethodCall('setAdminGroups', [$groups]);
        $pool->addMethodCall('setAdminClasses', [$classes]);

        $routeLoader = $container->getDefinition('sonata.admin.route_loader');
        $routeLoader->replaceArgument(1, $admins);
    }

    /**
     * This method read the attribute keys and configure admin class to use the related dependency.
     */
    public function applyConfigurationFromAttribute(Definition $definition, array $attributes): void
    {
        $keys = [
            'model_manager',
            'form_contractor',
            'show_builder',
            'list_builder',
            'datagrid_builder',
            'translator',
            'configuration_pool',
            'router',
            'validator',
            'security_handler',
            'menu_factory',
            'route_builder',
            'label_translator_strategy',
        ];

        foreach ($keys as $key) {
            $method = $this->generateSetterMethodName($key);
            if (!isset($attributes[$key]) || $definition->hasMethodCall($method)) {
                continue;
            }

            $definition->addMethodCall($method, [new Reference($attributes[$key])]);
        }
    }

    /**
     * Apply the default values required by the AdminInterface to the Admin service definition.
     *
     * @param string $serviceId
     *
     * @return Definition
     */
    public function applyDefaults(ContainerBuilder $container, $serviceId, array $attributes = [])
    {
        $definition = $container->getDefinition($serviceId);
        $settings = $container->getParameter('sonata.admin.configuration.admin_services');

        $definition->setShared(false);

        $managerType = $attributes['manager_type'];

        $overwriteAdminConfiguration = $settings[$serviceId] ?? [];

        $defaultAddServices = [
            'model_manager' => sprintf('sonata.admin.manager.%s', $managerType),
            'form_contractor' => sprintf('sonata.admin.builder.%s_form', $managerType),
            'show_builder' => sprintf('sonata.admin.builder.%s_show', $managerType),
            'list_builder' => sprintf('sonata.admin.builder.%s_list', $managerType),
            'datagrid_builder' => sprintf('sonata.admin.builder.%s_datagrid', $managerType),
            'translator' => 'translator',
            'configuration_pool' => 'sonata.admin.pool',
            'route_generator' => 'sonata.admin.route.default_generator',
            'validator' => 'validator',
            'security_handler' => 'sonata.admin.security.handler',
            'menu_factory' => 'knp_menu.factory',
            'route_builder' => 'sonata.admin.route.path_info'.
                (('doctrine_phpcr' === $managerType) ? '_slashes' : ''),
            'label_translator_strategy' => 'sonata.admin.label.strategy.native',
        ];

        $definition->addMethodCall('setManagerType', [$managerType]);

        foreach ($defaultAddServices as $attr => $addServiceId) {
            $method = $this->generateSetterMethodName($attr);

            if (isset($overwriteAdminConfiguration[$attr]) || !$definition->hasMethodCall($method)) {
                $args = [new Reference($overwriteAdminConfiguration[$attr] ?? $addServiceId)];
                if ('translator' === $attr) {
                    $args[] = false;
                }

                $definition->addMethodCall($method, $args);
            }
        }

        if (isset($overwriteAdminConfiguration['pager_type'])) {
            $pagerType = $overwriteAdminConfiguration['pager_type'];
        } elseif (isset($attributes['pager_type'])) {
            $pagerType = $attributes['pager_type'];
        } else {
            $pagerType = Pager::TYPE_DEFAULT;
        }

        $definition->addMethodCall('setPagerType', [$pagerType]);

        if (isset($overwriteAdminConfiguration['label'])) {
            $label = $overwriteAdminConfiguration['label'];
        } elseif (isset($attributes['label'])) {
            $label = $attributes['label'];
        } else {
            $label = '-';
        }

        $definition->addMethodCall('setLabel', [$label]);

        $persistFilters = $container->getParameter('sonata.admin.configuration.filters.persist');
        // override default configuration with admin config if set
        if (isset($attributes['persist_filters'])) {
            $persistFilters = $attributes['persist_filters'];
        }
        $filtersPersister = $container->getParameter('sonata.admin.configuration.filters.persister');
        // override default configuration with admin config if set
        if (isset($attributes['filter_persister'])) {
            $filtersPersister = $attributes['filter_persister'];
        }
        // configure filters persistence, if configured to
        if ($persistFilters) {
            $definition->addMethodCall('setFilterPersister', [new Reference($filtersPersister)]);
        }

        if (isset($overwriteAdminConfiguration['show_mosaic_button'])) {
            $showMosaicButton = $overwriteAdminConfiguration['show_mosaic_button'];
        } elseif (isset($attributes['show_mosaic_button'])) {
            $showMosaicButton = $attributes['show_mosaic_button'];
        } else {
            $showMosaicButton = $container->getParameter('sonata.admin.configuration.show.mosaic.button');
        }

        $definition->addMethodCall('showMosaicButton', [$showMosaicButton]);

        $this->fixTemplates(
            $serviceId,
            $container,
            $definition,
            $overwriteAdminConfiguration['templates'] ?? ['view' => []]
        );

        if ($container->hasParameter('sonata.admin.configuration.security.information') && !$definition->hasMethodCall('setSecurityInformation')) {
            $definition->addMethodCall('setSecurityInformation', ['%sonata.admin.configuration.security.information%']);
        }

        $definition->addMethodCall('initialize');

        return $definition;
    }

    public function fixTemplates(
        string $serviceId,
        ContainerBuilder $container,
        Definition $definition,
        array $overwrittenTemplates = []
    ): void {
        $definedTemplates = $container->getParameter('sonata.admin.configuration.templates');

        $methods = [];
        $pos = 0;
        foreach ($definition->getMethodCalls() as $method) {
            if ('setTemplates' === $method[0]) {
                $definedTemplates = array_merge($definedTemplates, $method[1][0]);

                continue;
            }

            if ('setTemplate' === $method[0]) {
                $definedTemplates[$method[1][0]] = $method[1][1];

                continue;
            }

            // set template for simple pager if it is not already overwritten
            if ('setPagerType' === $method[0]
                && Pager::TYPE_SIMPLE === $method[1][0]
                && (
                    !isset($definedTemplates['pager_results'])
                    || '@SonataAdmin/Pager/results.html.twig' === $definedTemplates['pager_results']
                )
            ) {
                $definedTemplates['pager_results'] = '@SonataAdmin/Pager/simple_pager_results.html.twig';
            }

            $methods[$pos] = $method;
            ++$pos;
        }

        $definition->setMethodCalls($methods);

        $definedTemplates = $overwrittenTemplates['view'] + $definedTemplates;

        $templateRegistryId = $serviceId.'.template_registry';
        $templateRegistryDefinition = $container
            ->register($templateRegistryId, TemplateRegistry::class)
            ->addTag('sonata.admin.template_registry')
            ->setPublic(true); // Temporary fix until we can support service locators

        if ($container->getParameter('sonata.admin.configuration.templates') !== $definedTemplates) {
            $templateRegistryDefinition->addArgument($definedTemplates);
        } else {
            $templateRegistryDefinition->addArgument('%sonata.admin.configuration.templates%');
        }

        $definition->addMethodCall('setTemplateRegistry', [new Reference($templateRegistryId)]);
    }

    /**
     * Replace the empty arguments required by the Admin service definition.
     */
    private function replaceDefaultArguments(
        array $defaultArguments,
        Definition $definition,
        ?Definition $parentDefinition = null
    ): void {
        $arguments = $definition->getArguments();
        $parentArguments = $parentDefinition ? $parentDefinition->getArguments() : [];

        foreach ($defaultArguments as $index => $value) {
            $declaredInParent = $parentDefinition && \array_key_exists($index, $parentArguments);
            $argumentValue = $declaredInParent ? $parentArguments[$index] : $arguments[$index];

            if (null === $argumentValue || 0 === \strlen($argumentValue)) {
                $arguments[$declaredInParent ? sprintf('index_%s', $index) : $index] = $value;
            }
        }

        $definition->setArguments($arguments);
    }

    private function generateSetterMethodName(string $key): string
    {
        return 'set'.InflectorFactory::create()->build()->classify($key);
    }
}


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 Doctrine\Inflector\InflectorFactory;
17			use Sonata\AdminBundle\Controller\CRUDController;
18			use Sonata\AdminBundle\Datagrid\Pager;
19			use Sonata\AdminBundle\Templating\TemplateRegistry;
20			use Symfony\Component\DependencyInjection\ChildDefinition;
21			use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
22			use Symfony\Component\DependencyInjection\ContainerBuilder;
23			use Symfony\Component\DependencyInjection\Definition;
24			use Symfony\Component\DependencyInjection\Reference;
25
26			/**
27			* Add all dependencies to the Admin class, this avoid to write too many lines
28			* in the configuration files.
29			*
30			* @final since sonata-project/admin-bundle 3.52
31			*
32			* @author Thomas Rabaix <[email protected]>
33			*/
34			final class AddDependencyCallsCompilerPass implements CompilerPassInterface
35			{
36			public function process(ContainerBuilder $container): void
37			{
38			// check if translator service exist
39			if (!$container->has('translator')) {
40			throw new \RuntimeException('The "translator" service is not yet enabled.
41			It\'s required by SonataAdmin to display all labels properly.
42
43			To learn how to enable the translator service please visit:
44			http://symfony.com/doc/current/translation.html#configuration
45			');
46			}
47
48			$parameterBag = $container->getParameterBag();
49			$groupDefaults = $admins = $classes = [];
50
51			$pool = $container->getDefinition('sonata.admin.pool');
52
53			foreach ($container->findTaggedServiceIds('sonata.admin') as $id => $tags) {
54			foreach ($tags as $attributes) {
55			$definition = $container->getDefinition($id);
56			$parentDefinition = null;
57
58			// Temporary fix until we can support service locators
59			$definition->setPublic(true);
60
61			if ($definition instanceof ChildDefinition) {
62			$parentDefinition = $container->getDefinition($definition->getParent());
63			}
64
65			$this->replaceDefaultArguments([
66			0 => $id,
67			2 => CRUDController::class,
68			], $definition, $parentDefinition);
69			$this->applyConfigurationFromAttribute($definition, $attributes);
70			$this->applyDefaults($container, $id, $attributes);
71
72			$arguments = $parentDefinition ?
73			array_merge($parentDefinition->getArguments(), $definition->getArguments()) :
74			$definition->getArguments();
75
76			$admins[] = $id;
77
78			if (!isset($classes[$arguments[1]])) {
79			$classes[$arguments[1]] = [];
80			}
81
82			$classes[$arguments[1]][] = $id;
83
84			$showInDashboard = (bool) (isset($attributes['show_in_dashboard']) ? $parameterBag->resolveValue($attributes['show_in_dashboard']) : true);
85			if (!$showInDashboard) {
86			continue;
87			}
88
89			$resolvedGroupName = isset($attributes['group']) ?
90			$parameterBag->resolveValue($attributes['group']) :
91			$container->getParameter('sonata.admin.configuration.default_group');
92			$labelCatalogue = $attributes['label_catalogue'] ??
93			$container->getParameter('sonata.admin.configuration.default_label_catalogue');
94			$icon = $attributes['icon'] ??
95			$container->getParameter('sonata.admin.configuration.default_icon');
96			$onTop = $attributes['on_top'] ?? false;
97			$keepOpen = $attributes['keep_open'] ?? false;
98
99			if (!isset($groupDefaults[$resolvedGroupName])) {
100			$groupDefaults[$resolvedGroupName] = [
101			'label' => $resolvedGroupName,
102			'label_catalogue' => $labelCatalogue,
103			'icon' => $icon,
104			'roles' => [],
105			'on_top' => false,
106			'keep_open' => false,
107			];
108			}
109
110			$groupDefaults[$resolvedGroupName]['items'][] = [
111			'admin' => $id,
112			'label' => !empty($attributes['label']) ? $attributes['label'] : '',
113			'route' => '',
114			'route_params' => [],
115			'route_absolute' => false,
116			];
117
118			if (isset($groupDefaults[$resolvedGroupName]['on_top']) && $groupDefaults[$resolvedGroupName]['on_top']
119			\|\| $onTop && (\count($groupDefaults[$resolvedGroupName]['items']) > 1)) {
120			throw new \RuntimeException('You can\'t use "on_top" option with multiple same name groups.');
121			}
122			$groupDefaults[$resolvedGroupName]['on_top'] = $onTop;
123
124			$groupDefaults[$resolvedGroupName]['keep_open'] = $keepOpen;
125			}
126			}
127
128			$dashboardGroupsSettings = $container->getParameter('sonata.admin.configuration.dashboard_groups');
129			if (!empty($dashboardGroupsSettings)) {
130			$groups = $dashboardGroupsSettings;
131
132			foreach ($dashboardGroupsSettings as $groupName => $group) {
133			$resolvedGroupName = $parameterBag->resolveValue($groupName);
134			if (!isset($groupDefaults[$resolvedGroupName])) {
135			$groupDefaults[$resolvedGroupName] = [
136			'items' => [],
137			'label' => $resolvedGroupName,
138			'roles' => [],
139			'on_top' => false,
140			'keep_open' => false,
141			];
142			}
143
144			if (empty($group['items'])) {
145			$groups[$resolvedGroupName]['items'] = $groupDefaults[$resolvedGroupName]['items'];
146			}
147
148			if (empty($group['label'])) {
149			$groups[$resolvedGroupName]['label'] = $groupDefaults[$resolvedGroupName]['label'];
150			}
151
152			if (empty($group['label_catalogue'])) {
153			$groups[$resolvedGroupName]['label_catalogue'] = 'SonataAdminBundle';
154			}
155
156			if (empty($group['icon'])) {
157			$groups[$resolvedGroupName]['icon'] = $groupDefaults[$resolvedGroupName]['icon'];
158			}
159
160			if (!empty($group['item_adds'])) {
161			$groups[$resolvedGroupName]['items'] = array_merge($groups[$resolvedGroupName]['items'], $group['item_adds']);
162			}
163
164			if (empty($group['roles'])) {
165			$groups[$resolvedGroupName]['roles'] = $groupDefaults[$resolvedGroupName]['roles'];
166			}
167
168			if (isset($groups[$resolvedGroupName]['on_top']) && !empty($group['on_top']) && $group['on_top']
169			&& (\count($groups[$resolvedGroupName]['items']) > 1)) {
170			throw new \RuntimeException('You can\'t use "on_top" option with multiple same name groups.');
171			}
172			if (empty($group['on_top'])) {
173			$groups[$resolvedGroupName]['on_top'] = $groupDefaults[$resolvedGroupName]['on_top'];
174			}
175
176			if (empty($group['keep_open'])) {
177			$groups[$resolvedGroupName]['keep_open'] = $groupDefaults[$resolvedGroupName]['keep_open'];
178			}
179			}
180			} elseif ($container->getParameter('sonata.admin.configuration.sort_admins')) {
181			$groups = $groupDefaults;
182
183			$elementSort = static function (&$element): void {
184			usort(
185			$element['items'],
186			static function ($a, $b) {
187			$a = !empty($a['label']) ? $a['label'] : $a['admin'];
188			$b = !empty($b['label']) ? $b['label'] : $b['admin'];
189
190			if ($a === $b) {
191			return 0;
192			}
193
194			return $a < $b ? -1 : 1;
195			}
196			);
197			};
198
199			/*
200			* 1) sort the groups by their index
201			* 2) sort the elements within each group by label/admin
202			*/
203			ksort($groups);
204			array_walk($groups, $elementSort);
205			} else {
206			$groups = $groupDefaults;
207			}
208
209			$pool->addMethodCall('setAdminServiceIds', [$admins]);
210			$pool->addMethodCall('setAdminGroups', [$groups]);
211			$pool->addMethodCall('setAdminClasses', [$classes]);
212
213			$routeLoader = $container->getDefinition('sonata.admin.route_loader');
214			$routeLoader->replaceArgument(1, $admins);
215			}
216
217			/**
218			* This method read the attribute keys and configure admin class to use the related dependency.
219			*/
220			public function applyConfigurationFromAttribute(Definition $definition, array $attributes): void
221			{
222			$keys = [
223			'model_manager',
224			'form_contractor',
225			'show_builder',
226			'list_builder',
227			'datagrid_builder',
228			'translator',
229			'configuration_pool',
230			'router',
231			'validator',
232			'security_handler',
233			'menu_factory',
234			'route_builder',
235			'label_translator_strategy',
236			];
237
238			foreach ($keys as $key) {
239			$method = $this->generateSetterMethodName($key);
240			if (!isset($attributes[$key]) \|\| $definition->hasMethodCall($method)) {
241			continue;
242			}
243
244			$definition->addMethodCall($method, [new Reference($attributes[$key])]);
245			}
246			}
247
248			/**
249			* Apply the default values required by the AdminInterface to the Admin service definition.
250			*
251			* @param string $serviceId
252			*
253			* @return Definition
254			*/
255			public function applyDefaults(ContainerBuilder $container, $serviceId, array $attributes = [])
256			{
257			$definition = $container->getDefinition($serviceId);
258			$settings = $container->getParameter('sonata.admin.configuration.admin_services');
259
260			$definition->setShared(false);
261
262			$managerType = $attributes['manager_type'];
263
264			$overwriteAdminConfiguration = $settings[$serviceId] ?? [];
265
266			$defaultAddServices = [
267			'model_manager' => sprintf('sonata.admin.manager.%s', $managerType),
268			'form_contractor' => sprintf('sonata.admin.builder.%s_form', $managerType),
269			'show_builder' => sprintf('sonata.admin.builder.%s_show', $managerType),
270			'list_builder' => sprintf('sonata.admin.builder.%s_list', $managerType),
271			'datagrid_builder' => sprintf('sonata.admin.builder.%s_datagrid', $managerType),
272			'translator' => 'translator',
273			'configuration_pool' => 'sonata.admin.pool',
274			'route_generator' => 'sonata.admin.route.default_generator',
275			'validator' => 'validator',
276			'security_handler' => 'sonata.admin.security.handler',
277			'menu_factory' => 'knp_menu.factory',
278			'route_builder' => 'sonata.admin.route.path_info'.
279			(('doctrine_phpcr' === $managerType) ? '_slashes' : ''),
280			'label_translator_strategy' => 'sonata.admin.label.strategy.native',
281			];
282
283			$definition->addMethodCall('setManagerType', [$managerType]);
284
285			foreach ($defaultAddServices as $attr => $addServiceId) {
286			$method = $this->generateSetterMethodName($attr);
287
288			if (isset($overwriteAdminConfiguration[$attr]) \|\| !$definition->hasMethodCall($method)) {
289			$args = [new Reference($overwriteAdminConfiguration[$attr] ?? $addServiceId)];
290			if ('translator' === $attr) {
291			$args[] = false;
292			}
293
294			$definition->addMethodCall($method, $args);
295			}
296			}
297
298			if (isset($overwriteAdminConfiguration['pager_type'])) {
299			$pagerType = $overwriteAdminConfiguration['pager_type'];
300			} elseif (isset($attributes['pager_type'])) {
301			$pagerType = $attributes['pager_type'];
302			} else {
303			$pagerType = Pager::TYPE_DEFAULT;
304			}
305
306			$definition->addMethodCall('setPagerType', [$pagerType]);
307
308			if (isset($overwriteAdminConfiguration['label'])) {
309			$label = $overwriteAdminConfiguration['label'];
310			} elseif (isset($attributes['label'])) {
311			$label = $attributes['label'];
312			} else {
313			$label = '-';
314			}
315
316			$definition->addMethodCall('setLabel', [$label]);
317
318			$persistFilters = $container->getParameter('sonata.admin.configuration.filters.persist');
319			// override default configuration with admin config if set
320			if (isset($attributes['persist_filters'])) {
321			$persistFilters = $attributes['persist_filters'];
322			}
323			$filtersPersister = $container->getParameter('sonata.admin.configuration.filters.persister');
324			// override default configuration with admin config if set
325			if (isset($attributes['filter_persister'])) {
326			$filtersPersister = $attributes['filter_persister'];
327			}
328			// configure filters persistence, if configured to
329			if ($persistFilters) {
330			$definition->addMethodCall('setFilterPersister', [new Reference($filtersPersister)]);
331			}
332
333			if (isset($overwriteAdminConfiguration['show_mosaic_button'])) {
334			$showMosaicButton = $overwriteAdminConfiguration['show_mosaic_button'];
335			} elseif (isset($attributes['show_mosaic_button'])) {
336			$showMosaicButton = $attributes['show_mosaic_button'];
337			} else {
338			$showMosaicButton = $container->getParameter('sonata.admin.configuration.show.mosaic.button');
339			}
340
341			$definition->addMethodCall('showMosaicButton', [$showMosaicButton]);
342
343			$this->fixTemplates(
344			$serviceId,
345			$container,
346			$definition,
347			$overwriteAdminConfiguration['templates'] ?? ['view' => []]
348			);
349
350			if ($container->hasParameter('sonata.admin.configuration.security.information') && !$definition->hasMethodCall('setSecurityInformation')) {
351			$definition->addMethodCall('setSecurityInformation', ['%sonata.admin.configuration.security.information%']);
352			}
353
354			$definition->addMethodCall('initialize');
355
356			return $definition;
357			}
358
359			public function fixTemplates(
360			string $serviceId,
361			ContainerBuilder $container,
362			Definition $definition,
363			array $overwrittenTemplates = []
364			): void {
365			$definedTemplates = $container->getParameter('sonata.admin.configuration.templates');
366
367			$methods = [];
368			$pos = 0;
369			foreach ($definition->getMethodCalls() as $method) {
370			if ('setTemplates' === $method[0]) {
371			$definedTemplates = array_merge($definedTemplates, $method[1][0]);
372
373			continue;
374			}
375
376			if ('setTemplate' === $method[0]) {
377			$definedTemplates[$method[1][0]] = $method[1][1];
378
379			continue;
380			}
381
382			// set template for simple pager if it is not already overwritten
383			if ('setPagerType' === $method[0]
384			&& Pager::TYPE_SIMPLE === $method[1][0]
385			&& (
386			!isset($definedTemplates['pager_results'])
387			\|\| '@SonataAdmin/Pager/results.html.twig' === $definedTemplates['pager_results']
388			)
389			) {
390			$definedTemplates['pager_results'] = '@SonataAdmin/Pager/simple_pager_results.html.twig';
391			}
392
393			$methods[$pos] = $method;
394			++$pos;
395			}
396
397			$definition->setMethodCalls($methods);
398
399			$definedTemplates = $overwrittenTemplates['view'] + $definedTemplates;
400
401			$templateRegistryId = $serviceId.'.template_registry';
402			$templateRegistryDefinition = $container
403			->register($templateRegistryId, TemplateRegistry::class)
404			->addTag('sonata.admin.template_registry')
405			->setPublic(true); // Temporary fix until we can support service locators
406
407			if ($container->getParameter('sonata.admin.configuration.templates') !== $definedTemplates) {
408			$templateRegistryDefinition->addArgument($definedTemplates);
409			} else {
410			$templateRegistryDefinition->addArgument('%sonata.admin.configuration.templates%');
411			}
412
413			$definition->addMethodCall('setTemplateRegistry', [new Reference($templateRegistryId)]);
414			}
415
416			/**
417			* Replace the empty arguments required by the Admin service definition.
418			*/
419			private function replaceDefaultArguments(
420			array $defaultArguments,
421			Definition $definition,
422			?Definition $parentDefinition = null
423			): void {
424			$arguments = $definition->getArguments();
425			$parentArguments = $parentDefinition ? $parentDefinition->getArguments() : [];
426
427			foreach ($defaultArguments as $index => $value) {
428			$declaredInParent = $parentDefinition && \array_key_exists($index, $parentArguments);
429			$argumentValue = $declaredInParent ? $parentArguments[$index] : $arguments[$index];
430
431			if (null === $argumentValue \|\| 0 === \strlen($argumentValue)) {
432			$arguments[$declaredInParent ? sprintf('index_%s', $index) : $index] = $value;
433			}
434			}
435
436			$definition->setArguments($arguments);
437			}
438
439			private function generateSetterMethodName(string $key): string
440			{
441			return 'set'.InflectorFactory::create()->build()->classify($key);
442			}
443			}
444

sonata-project / SonataAdminBundle

Pull Request — master (#6097)

AddDependencyCallsCompilerPass::process() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like