Contextualizer::mergeSettingsForSiteAccess() - Code Metrics - Inspection of "fix: Coding Standards" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — ezp-30639-deprecated-view-acti... ( 6b3a78...0a459a )

unknown

created 2020-02-05 11:05 UTC

Contextualizer::mergeSettingsForSiteAccess() C

↳ Parent: Contextualizer

Complexity

Conditions	13
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	13
nc	4
nop	5
dl	0
loc	63
rs	6.1006
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

/**
 * File containing the Contextualizer class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Bundle\EzPublishCoreBundle\DependencyInjection\Configuration\SiteAccessAware;

use eZ\Bundle\EzPublishCoreBundle\DependencyInjection\Configuration\ConfigResolver;
use Symfony\Component\DependencyInjection\ContainerInterface;

class Contextualizer implements ContextualizerInterface
{
    /** @var \Symfony\Component\DependencyInjection\ContainerInterface */
    private $container;

    /** @var string */
    private $namespace;

    /**
     * Name of the node under which scope based (semantic) configuration takes place.
     *
     * @var string
     */
    private $siteAccessNodeName;

    /** @var array */
    private $availableSiteAccesses;

    /** @var array */
    private $availableSiteAccessGroups;

    /** @var array */
    private $groupsBySiteAccess;

    public function __construct(
        ContainerInterface $containerBuilder,
        $namespace,
        $siteAccessNodeName,
        array $availableSiteAccesses,
        array $availableSiteAccessGroups,
        array $groupsBySiteAccess
    ) {
        $this->container = $containerBuilder;
        $this->namespace = $namespace;
        $this->siteAccessNodeName = $siteAccessNodeName;
        $this->availableSiteAccesses = $availableSiteAccesses;
        $this->availableSiteAccessGroups = $availableSiteAccessGroups;
        $this->groupsBySiteAccess = $groupsBySiteAccess;
    }

    public function setContextualParameter($parameterName, $scope, $value)
    {
        $this->container->setParameter("$this->namespace.$scope.$parameterName", $value);
    }

    public function mapSetting($id, array $config)
    {
        foreach ($config[$this->siteAccessNodeName] as $currentScope => $scopeSettings) {
            if (isset($scopeSettings[$id])) {
                $this->setContextualParameter($id, $currentScope, $scopeSettings[$id]);
            }
        }
    }

    public function mapConfigArray($id, array $config, $options = 0)
    {
        $this->mapReservedScopeArray($id, $config, ConfigResolver::SCOPE_DEFAULT);
        $this->mapReservedScopeArray($id, $config, ConfigResolver::SCOPE_GLOBAL);
        $defaultSettings = $this->getContainerParameter(
            $this->namespace . '.' . ConfigResolver::SCOPE_DEFAULT . '.' . $id,
            []
        );
        $globalSettings = $this->getContainerParameter(
            $this->namespace . '.' . ConfigResolver::SCOPE_GLOBAL . '.' . $id,
            []
        );

        // (!) Keep SiteAccess group settings
        foreach (array_keys($this->availableSiteAccessGroups) as $scope) {
            $scopeSettings = $config[$this->siteAccessNodeName][$scope][$id] ?? [];
            if (empty($scopeSettings)) {
                continue;
            }

            $mergedSettings = $this->mergeSettingsForSiteAccessGroup(
                $options,
                $defaultSettings,
                $scopeSettings,
                $globalSettings
            );

            $this->container->setParameter("$this->namespace.$scope.$id", $mergedSettings);
        }

        foreach ($this->availableSiteAccesses as $scope) {
            // for a siteaccess, we have to merge the default value,
            // the group value(s), the siteaccess value and the global
            // value of the settings.
            $groupsSettings = [];
            if (isset($this->groupsBySiteAccess[$scope]) && is_array($this->groupsBySiteAccess[$scope])) {
                $groupsSettings = $this->groupsArraySetting(
                    $this->groupsBySiteAccess[$scope],
                    $id,
                    $config,
                    $options & static::MERGE_FROM_SECOND_LEVEL
                );
            }

            $scopeSettings = [];
            if (isset($config[$this->siteAccessNodeName][$scope][$id])) {
                $scopeSettings = $config[$this->siteAccessNodeName][$scope][$id];
            }

            if (empty($groupsSettings) && empty($scopeSettings)) {
                continue;
            }

            $mergedSettings = $this->mergeSettingsForSiteAccess(
                $options,
                $defaultSettings,
                $groupsSettings,
                $scopeSettings,
                $globalSettings
            );

            $this->container->setParameter("$this->namespace.$scope.$id", $mergedSettings);
        }
    }

    /**
     * Returns the value under the $id in the $container. if the container does
     * not known this $id, returns $default.
     *
     * @param string $id
     * @param mixed $default
     *
     * @return mixed
     */
    protected function getContainerParameter($id, $default = null)
    {
        if ($this->container->hasParameter($id)) {
            return $this->container->getParameter($id);
        }

        return $default;
    }

    /**
     * Merges setting array for a set of groups.
     *
     * @param array $groups array of group name
     * @param string $id id of the setting array under ezpublish.<base_key>.<group_name>
     * @param array $config the full configuration array
     * @param int $options only static::MERGE_FROM_SECOND_LEVEL or static::UNIQUE are recognized
     *
     * @return array
     */
    private function groupsArraySetting(array $groups, $id, array $config, $options = 0)
    {
        $groupsSettings = [];
        sort($groups);
        foreach ($groups as $group) {
            if (isset($config[$this->siteAccessNodeName][$group][$id])) {
                if ($options & static::MERGE_FROM_SECOND_LEVEL) {
                    foreach (array_keys($config[$this->siteAccessNodeName][$group][$id]) as $key) {
                        if (!isset($groupsSettings[$key])) {
                            $groupsSettings[$key] = $config[$this->siteAccessNodeName][$group][$id][$key];
                        } else {
                            // array_merge() has to be used because we don't
                            // know whether we have a hash or a plain array
                            $groupsSettings[$key] = array_merge(
                                $groupsSettings[$key],
                                $config[$this->siteAccessNodeName][$group][$id][$key]
                            );
                        }
                    }
                } else {
                    // array_merge() has to be used because we don't
                    // know whether we have a hash or a plain array
                    $groupsSettings = array_merge(
                        $groupsSettings,
                        $config[$this->siteAccessNodeName][$group][$id]
                    );
                }
            }
        }

        return $groupsSettings;
    }

    /**
     * Ensures settings array defined in a given "reserved scope" are registered properly.
     * "Reserved scope" can typically be ConfigResolver::SCOPE_DEFAULT or ConfigResolver::SCOPE_GLOBAL.
     *
     * @param string $id
     * @param string $scope
     */
    private function mapReservedScopeArray($id, array $config, $scope)
    {
        if (
            isset($config[$this->siteAccessNodeName][$scope][$id])
            && !empty($config[$this->siteAccessNodeName][$scope][$id])
        ) {
            $key = "$this->namespace.$scope.$id";
            $value = $config[$this->siteAccessNodeName][$scope][$id];
            if ($this->container->hasParameter($key)) {
                $value = array_merge(
                    $this->container->getParameter($key),
                    $value
                );
            }
            $this->container->setParameter($key, $value);
        }
    }

    public function setContainer(ContainerInterface $container)
    {
        $this->container = $container;
    }

    public function getContainer()
    {
        return $this->container;
    }

    public function setSiteAccessNodeName($scopeNodeName)
    {
        $this->siteAccessNodeName = $scopeNodeName;
    }

    public function getSiteAccessNodeName()
    {
        return $this->siteAccessNodeName;
    }

    public function setNamespace($namespace)
    {
        $this->namespace = $namespace;
    }

    public function getNamespace()
    {
        return $this->namespace;
    }

    public function setAvailableSiteAccesses(array $availableSiteAccesses)
    {
        $this->availableSiteAccesses = $availableSiteAccesses;
    }

    public function getAvailableSiteAccesses()
    {
        return $this->availableSiteAccesses;
    }

    public function setGroupsBySiteAccess(array $groupsBySiteAccess)
    {
        $this->groupsBySiteAccess = $groupsBySiteAccess;
    }

    public function getGroupsBySiteAccess()
    {
        return $this->groupsBySiteAccess;
    }

    private function mergeSettingsForSiteAccessGroup(
        int $options,
        array $defaultSettings,
        array $scopeSettings,
        array $globalSettings
    ): array {
        if ($options & static::MERGE_FROM_SECOND_LEVEL) {
            $mergedSettings = [];

            // array_merge() has to be used because we don't
            // know whether we have a hash or a plain array
            $keys = array_unique(
                array_merge(
                    array_keys($defaultSettings),
                    array_keys($scopeSettings),
                    array_keys($globalSettings)
                )
            );
            foreach ($keys as $key) {
                // Only merge if actual setting is an array.
                // We assume default setting to be a clear reference for this.
                // If the setting is not an array, we copy the right value, in respect to the precedence:
                // 1. global
                // 3. Group
                // 4. default
                if (array_key_exists($key, $defaultSettings) && !is_array($defaultSettings[$key])) {
                    if (array_key_exists($key, $globalSettings)) {
                        $mergedSettings[$key] = $globalSettings[$key];
                    } elseif (array_key_exists($key, $scopeSettings)) {
                        $mergedSettings[$key] = $scopeSettings[$key];
                    } else {
                        $mergedSettings[$key] = $defaultSettings[$key];
                    }
                } else {
                    $mergedSettings[$key] = array_merge(
                        $defaultSettings[$key] ?? [],
                        $scopeSettings[$key] ?? [],
                        $globalSettings[$key] ?? []
                    );
                }
            }
        } else {
            $mergedSettings = array_merge(
                $defaultSettings,
                $scopeSettings,
                $globalSettings
            );
        }
        if ($options & static::UNIQUE) {
            $mergedSettings = array_values(
                array_unique($mergedSettings)
            );
        }

        return $mergedSettings;
    }

    private function mergeSettingsForSiteAccess(
        int $options,
        array $defaultSettings,
        array $groupsSettings,
        array $scopeSettings,
        array $globalSettings
    ): array {
        if ($options & static::MERGE_FROM_SECOND_LEVEL) {
            // array_merge() has to be used because we don't
            // know whether we have a hash or a plain array
            $keys1 = array_unique(
                array_merge(
                    array_keys($defaultSettings),
                    array_keys($groupsSettings),
                    array_keys($scopeSettings),
                    array_keys($globalSettings)
                )
            );
            $mergedSettings = [];
            foreach ($keys1 as $key) {
                // Only merge if actual setting is an array.
                // We assume default setting to be a clear reference for this.
                // If the setting is not an array, we copy the right value, in respect to the precedence:
                // 1. global
                // 2. SiteAccess
                // 3. Group
                // 4. default
                if (array_key_exists($key, $defaultSettings) && !is_array($defaultSettings[$key])) {
                    if (array_key_exists($key, $globalSettings)) {
                        $mergedSettings[$key] = $globalSettings[$key];
                    } elseif (array_key_exists($key, $scopeSettings)) {
                        $mergedSettings[$key] = $scopeSettings[$key];
                    } elseif (array_key_exists($key, $groupsSettings)) {
                        $mergedSettings[$key] = $groupsSettings[$key];
                    } else {
                        $mergedSettings[$key] = $defaultSettings[$key];
                    }
                } else {
                    $mergedSettings[$key] = array_merge(
                        isset($defaultSettings[$key]) ? $defaultSettings[$key] : [],
                        isset($groupsSettings[$key]) ? $groupsSettings[$key] : [],
                        isset($scopeSettings[$key]) ? $scopeSettings[$key] : [],
                        isset($globalSettings[$key]) ? $globalSettings[$key] : []
                    );
                }
            }
        } else {
            $mergedSettings = array_merge(
                $defaultSettings,
                $groupsSettings,
                $scopeSettings,
                $globalSettings
            );
        }

        if ($options & static::UNIQUE) {
            $mergedSettings = array_values(
                array_unique($mergedSettings)
            );
        }

        return $mergedSettings;
    }
}


1			<?php
2
3			/**
4			* File containing the Contextualizer class.
5			*
6			* @copyright Copyright (C) eZ Systems AS. All rights reserved.
7			* @license For full copyright and license information view LICENSE file distributed with this source code.
8			*/
9			namespace eZ\Bundle\EzPublishCoreBundle\DependencyInjection\Configuration\SiteAccessAware;
10
11			use eZ\Bundle\EzPublishCoreBundle\DependencyInjection\Configuration\ConfigResolver;
12			use Symfony\Component\DependencyInjection\ContainerInterface;
13
14			class Contextualizer implements ContextualizerInterface
15			{
16			/** @var \Symfony\Component\DependencyInjection\ContainerInterface */
17			private $container;
18
19			/** @var string */
20			private $namespace;
21
22			/**
23			* Name of the node under which scope based (semantic) configuration takes place.
24			*
25			* @var string
26			*/
27			private $siteAccessNodeName;
28
29			/** @var array */
30			private $availableSiteAccesses;
31
32			/** @var array */
33			private $availableSiteAccessGroups;
34
35			/** @var array */
36			private $groupsBySiteAccess;
37
38			public function __construct(
39			ContainerInterface $containerBuilder,
40			$namespace,
41			$siteAccessNodeName,
42			array $availableSiteAccesses,
43			array $availableSiteAccessGroups,
44			array $groupsBySiteAccess
45			) {
46			$this->container = $containerBuilder;
47			$this->namespace = $namespace;
48			$this->siteAccessNodeName = $siteAccessNodeName;
49			$this->availableSiteAccesses = $availableSiteAccesses;
50			$this->availableSiteAccessGroups = $availableSiteAccessGroups;
51			$this->groupsBySiteAccess = $groupsBySiteAccess;
52			}
53
54			public function setContextualParameter($parameterName, $scope, $value)
55			{
56			$this->container->setParameter("$this->namespace.$scope.$parameterName", $value);
57			}
58
59			public function mapSetting($id, array $config)
60			{
61			foreach ($config[$this->siteAccessNodeName] as $currentScope => $scopeSettings) {
62			if (isset($scopeSettings[$id])) {
63			$this->setContextualParameter($id, $currentScope, $scopeSettings[$id]);
64			}
65			}
66			}
67
68			public function mapConfigArray($id, array $config, $options = 0)
69			{
70			$this->mapReservedScopeArray($id, $config, ConfigResolver::SCOPE_DEFAULT);
71			$this->mapReservedScopeArray($id, $config, ConfigResolver::SCOPE_GLOBAL);
72			$defaultSettings = $this->getContainerParameter(
73			$this->namespace . '.' . ConfigResolver::SCOPE_DEFAULT . '.' . $id,
74			[]
75			);
76			$globalSettings = $this->getContainerParameter(
77			$this->namespace . '.' . ConfigResolver::SCOPE_GLOBAL . '.' . $id,
78			[]
79			);
80
81			// (!) Keep SiteAccess group settings
82			foreach (array_keys($this->availableSiteAccessGroups) as $scope) {
83			$scopeSettings = $config[$this->siteAccessNodeName][$scope][$id] ?? [];
84			if (empty($scopeSettings)) {
85			continue;
86			}
87
88			$mergedSettings = $this->mergeSettingsForSiteAccessGroup(
89			$options,
90			$defaultSettings,
91			$scopeSettings,
92			$globalSettings
93			);
94
95			$this->container->setParameter("$this->namespace.$scope.$id", $mergedSettings);
96			}
97
98			foreach ($this->availableSiteAccesses as $scope) {
99			// for a siteaccess, we have to merge the default value,
100			// the group value(s), the siteaccess value and the global
101			// value of the settings.
102			$groupsSettings = [];
103			if (isset($this->groupsBySiteAccess[$scope]) && is_array($this->groupsBySiteAccess[$scope])) {
104			$groupsSettings = $this->groupsArraySetting(
105			$this->groupsBySiteAccess[$scope],
106			$id,
107			$config,
108			$options & static::MERGE_FROM_SECOND_LEVEL
109			);
110			}
111
112			$scopeSettings = [];
113			if (isset($config[$this->siteAccessNodeName][$scope][$id])) {
114			$scopeSettings = $config[$this->siteAccessNodeName][$scope][$id];
115			}
116
117			if (empty($groupsSettings) && empty($scopeSettings)) {
118			continue;
119			}
120
121			$mergedSettings = $this->mergeSettingsForSiteAccess(
122			$options,
123			$defaultSettings,
124			$groupsSettings,
125			$scopeSettings,
126			$globalSettings
127			);
128
129			$this->container->setParameter("$this->namespace.$scope.$id", $mergedSettings);
130			}
131			}
132
133			/**
134			* Returns the value under the $id in the $container. if the container does
135			* not known this $id, returns $default.
136			*
137			* @param string $id
138			* @param mixed $default
139			*
140			* @return mixed
141			*/
142			protected function getContainerParameter($id, $default = null)
143			{
144			if ($this->container->hasParameter($id)) {
145			return $this->container->getParameter($id);
146			}
147
148			return $default;
149			}
150
151			/**
152			* Merges setting array for a set of groups.
153			*
154			* @param array $groups array of group name
155			* @param string $id id of the setting array under ezpublish.<base_key>.<group_name>
156			* @param array $config the full configuration array
157			* @param int $options only static::MERGE_FROM_SECOND_LEVEL or static::UNIQUE are recognized
158			*
159			* @return array
160			*/
161			private function groupsArraySetting(array $groups, $id, array $config, $options = 0)
162			{
163			$groupsSettings = [];
164			sort($groups);
165			foreach ($groups as $group) {
166			if (isset($config[$this->siteAccessNodeName][$group][$id])) {
167			if ($options & static::MERGE_FROM_SECOND_LEVEL) {
168			foreach (array_keys($config[$this->siteAccessNodeName][$group][$id]) as $key) {
169			if (!isset($groupsSettings[$key])) {
170			$groupsSettings[$key] = $config[$this->siteAccessNodeName][$group][$id][$key];
171			} else {
172			// array_merge() has to be used because we don't
173			// know whether we have a hash or a plain array
174			$groupsSettings[$key] = array_merge(
175			$groupsSettings[$key],
176			$config[$this->siteAccessNodeName][$group][$id][$key]
177			);
178			}
179			}
180			} else {
181			// array_merge() has to be used because we don't
182			// know whether we have a hash or a plain array
183			$groupsSettings = array_merge(
184			$groupsSettings,
185			$config[$this->siteAccessNodeName][$group][$id]
186			);
187			}
188			}
189			}
190
191			return $groupsSettings;
192			}
193
194			/**
195			* Ensures settings array defined in a given "reserved scope" are registered properly.
196			* "Reserved scope" can typically be ConfigResolver::SCOPE_DEFAULT or ConfigResolver::SCOPE_GLOBAL.
197			*
198			* @param string $id
199			* @param string $scope
200			*/
201			private function mapReservedScopeArray($id, array $config, $scope)
202			{
203			if (
204			isset($config[$this->siteAccessNodeName][$scope][$id])
205			&& !empty($config[$this->siteAccessNodeName][$scope][$id])
206			) {
207			$key = "$this->namespace.$scope.$id";
208			$value = $config[$this->siteAccessNodeName][$scope][$id];
209			if ($this->container->hasParameter($key)) {
210			$value = array_merge(
211			$this->container->getParameter($key),
212			$value
213			);
214			}
215			$this->container->setParameter($key, $value);
216			}
217			}
218
219			public function setContainer(ContainerInterface $container)
220			{
221			$this->container = $container;
222			}
223
224			public function getContainer()
225			{
226			return $this->container;
227			}
228
229			public function setSiteAccessNodeName($scopeNodeName)
230			{
231			$this->siteAccessNodeName = $scopeNodeName;
232			}
233
234			public function getSiteAccessNodeName()
235			{
236			return $this->siteAccessNodeName;
237			}
238
239			public function setNamespace($namespace)
240			{
241			$this->namespace = $namespace;
242			}
243
244			public function getNamespace()
245			{
246			return $this->namespace;
247			}
248
249			public function setAvailableSiteAccesses(array $availableSiteAccesses)
250			{
251			$this->availableSiteAccesses = $availableSiteAccesses;
252			}
253
254			public function getAvailableSiteAccesses()
255			{
256			return $this->availableSiteAccesses;
257			}
258
259			public function setGroupsBySiteAccess(array $groupsBySiteAccess)
260			{
261			$this->groupsBySiteAccess = $groupsBySiteAccess;
262			}
263
264			public function getGroupsBySiteAccess()
265			{
266			return $this->groupsBySiteAccess;
267			}
268
269			private function mergeSettingsForSiteAccessGroup(
270			int $options,
271			array $defaultSettings,
272			array $scopeSettings,
273			array $globalSettings
274			): array {
275			if ($options & static::MERGE_FROM_SECOND_LEVEL) {
276			$mergedSettings = [];
277
278			// array_merge() has to be used because we don't
279			// know whether we have a hash or a plain array
280			$keys = array_unique(
281			array_merge(
282			array_keys($defaultSettings),
283			array_keys($scopeSettings),
284			array_keys($globalSettings)
285			)
286			);
287			foreach ($keys as $key) {
288			// Only merge if actual setting is an array.
289			// We assume default setting to be a clear reference for this.
290			// If the setting is not an array, we copy the right value, in respect to the precedence:
291			// 1. global
292			// 3. Group
293			// 4. default
294			if (array_key_exists($key, $defaultSettings) && !is_array($defaultSettings[$key])) {
295			if (array_key_exists($key, $globalSettings)) {
296			$mergedSettings[$key] = $globalSettings[$key];
297			} elseif (array_key_exists($key, $scopeSettings)) {
298			$mergedSettings[$key] = $scopeSettings[$key];
299			} else {
300			$mergedSettings[$key] = $defaultSettings[$key];
301			}
302			} else {
303			$mergedSettings[$key] = array_merge(
304			$defaultSettings[$key] ?? [],
305			$scopeSettings[$key] ?? [],
306			$globalSettings[$key] ?? []
307			);
308			}
309			}
310			} else {
311			$mergedSettings = array_merge(
312			$defaultSettings,
313			$scopeSettings,
314			$globalSettings
315			);
316			}
317			if ($options & static::UNIQUE) {
318			$mergedSettings = array_values(
319			array_unique($mergedSettings)
320			);
321			}
322
323			return $mergedSettings;
324			}
325
326			private function mergeSettingsForSiteAccess(
327			int $options,
328			array $defaultSettings,
329			array $groupsSettings,
330			array $scopeSettings,
331			array $globalSettings
332			): array {
333			if ($options & static::MERGE_FROM_SECOND_LEVEL) {
334			// array_merge() has to be used because we don't
335			// know whether we have a hash or a plain array
336			$keys1 = array_unique(
337			array_merge(
338			array_keys($defaultSettings),
339			array_keys($groupsSettings),
340			array_keys($scopeSettings),
341			array_keys($globalSettings)
342			)
343			);
344			$mergedSettings = [];
345			foreach ($keys1 as $key) {
346			// Only merge if actual setting is an array.
347			// We assume default setting to be a clear reference for this.
348			// If the setting is not an array, we copy the right value, in respect to the precedence:
349			// 1. global
350			// 2. SiteAccess
351			// 3. Group
352			// 4. default
353			if (array_key_exists($key, $defaultSettings) && !is_array($defaultSettings[$key])) {
354			if (array_key_exists($key, $globalSettings)) {
355			$mergedSettings[$key] = $globalSettings[$key];
356			} elseif (array_key_exists($key, $scopeSettings)) {
357			$mergedSettings[$key] = $scopeSettings[$key];
358			} elseif (array_key_exists($key, $groupsSettings)) {
359			$mergedSettings[$key] = $groupsSettings[$key];
360			} else {
361			$mergedSettings[$key] = $defaultSettings[$key];
362			}
363			} else {
364			$mergedSettings[$key] = array_merge(
365			isset($defaultSettings[$key]) ? $defaultSettings[$key] : [],
366			isset($groupsSettings[$key]) ? $groupsSettings[$key] : [],
367			isset($scopeSettings[$key]) ? $scopeSettings[$key] : [],
368			isset($globalSettings[$key]) ? $globalSettings[$key] : []
369			);
370			}
371			}
372			} else {
373			$mergedSettings = array_merge(
374			$defaultSettings,
375			$groupsSettings,
376			$scopeSettings,
377			$globalSettings
378			);
379			}
380
381			if ($options & static::UNIQUE) {
382			$mergedSettings = array_values(
383			array_unique($mergedSettings)
384			);
385			}
386
387			return $mergedSettings;
388			}
389			}
390

ezsystems / ezpublish-kernel

Push — ezp-30639-deprecated-view-acti... ( 6b3a78...0a459a )

Contextualizer::mergeSettingsForSiteAccess() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like