SolrFacetMaskAndCombineEnhancer::combineArrayParameters() - Code Metrics - Inspection of "Upcoming feature/introduce route enhancer" - TYPO3-Solr/ext-solr - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2755)

by Rafael

created 2021-08-18 07:49 UTC

combineArrayParameters() C

↳ Parent: SolrFacetMaskAndCombineEnhancer

Complexity

Conditions	15
Paths	86

Size

Total Lines	74
Code Lines	46

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	240

Importance

Changes

Metric	Value
eloc	46
dl	0
loc	74
ccs	0
cts	62
cp	0
rs	5.9166
c	0
b	0
f	0
cc	15
nc	86
nop	1
crap	240

How to fix Long Method Complexity

<?php
namespace ApacheSolrForTypo3\Solr\Routing\Enhancer;

use ApacheSolrForTypo3\Solr\Routing\RoutingService;
use ApacheSolrForTypo3\Solr\Utility\RoutingUtility;
use TYPO3\CMS\Core\Routing\Enhancer\AbstractEnhancer;
use TYPO3\CMS\Core\Routing\Enhancer\RoutingEnhancerInterface;
use TYPO3\CMS\Core\Routing\Route;
use TYPO3\CMS\Core\Routing\RouteCollection;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

class SolrFacetMaskAndCombineEnhancer extends AbstractEnhancer implements RoutingEnhancerInterface, SolrRouteEnhancerInterface
{
    /**
     * @var array
     */
    protected $configuration;

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

    public function __construct(array $configuration)
    {
        $this->configuration = $configuration;
        $this->namespace = $this->configuration['extensionKey'] ?? 'tx_solr';
    }

    /**
     * {@inheritdoc}
     */
    public function enhanceForMatching(RouteCollection $collection): void
    {
        /** @var Route $defaultPageRoute */
        $defaultPageRoute = $collection->get('default');
        $variant = $this->getVariant($defaultPageRoute, $this->configuration);
        $collection->add(
            'enhancer_' . $this->namespace . spl_object_hash($variant),
            $variant
        );
    }

    /**
     * Builds a variant of a route based on the given configuration.
     *
     * @param Route $defaultPageRoute
     * @param array $configuration
     * @return Route
     */
    protected function getVariant(Route $defaultPageRoute, array $configuration): Route
    {
        $arguments = $configuration['_arguments'] ?? [];
        unset($configuration['_arguments']);

        $variableProcessor = $this->getVariableProcessor();
        $routePath = $this->modifyRoutePath($configuration['routePath']);
        $routePath = $variableProcessor->deflateRoutePath($routePath, $this->namespace, $arguments);
        $variant = clone $defaultPageRoute;
        $variant->setPath(rtrim($variant->getPath(), '/') . '/' . ltrim($routePath, '/'));
        $variant->addOptions(['_enhancer' => $this, '_arguments' => $arguments]);
        $variant->setDefaults(
            $variableProcessor->deflateKeys($this->configuration['defaults'] ?? [], $this->namespace, $arguments)
        );
        $this->applyRouteAspects($variant, $this->aspects ?? [], $this->namespace);
        $this->applyRequirements($variant, $this->configuration['requirements'] ?? [], $this->namespace);
        return $variant;
    }

    /**
     * {@inheritdoc}
     */
    public function enhanceForGeneration(RouteCollection $collection, array $parameters): void
    {
        // No parameter for this namespace given, so this route does not fit the requirements
        if (!is_array($parameters[$this->namespace])) {
            return;
        }
        /** @var Route $defaultPageRoute */
        $defaultPageRoute = $collection->get('default');
        $variant = $this->getVariant($defaultPageRoute, $this->configuration);
        $compiledRoute = $variant->compile();
        $deflatedParameters = $this->deflateParameters($variant, $parameters);
        $deflatedParameters = $this->combineArrayParameters($deflatedParameters);
        $deflatedParameters = $this->inflateUnprocessedVariables($variant, $deflatedParameters);
        // TODO: Implode query parameters if configured!
        $deflatedParameters = $this->replaceVariableWithHash($variant, $deflatedParameters);
        $variant->setOption('deflatedParameters', $deflatedParameters);
        $variables = array_flip($compiledRoute->getPathVariables());
        $mergedParams = array_replace($variant->getDefaults(), $deflatedParameters);
        // all params must be given, otherwise we exclude this variant
        if (array_diff_key($variables, $mergedParams) !== []) {
            return;
        }

        $collection->add('enhancer_' . $this->namespace . spl_object_hash($variant), $variant);
    }

    /**
     * This method combine arguments into a single string
     * It is possible to configure a path segment that contains more than one value.
     * This method build one single string out of it.
     *
     * @param array $parameters
     * @return array
     */
    protected function combineArrayParameters(array $parameters = []): array
    {
        $parametersCombined = [];
        foreach ($this->configuration['_arguments'] as $fieldName => $fieldPath) {
            $combinedKey = RoutingUtility::deflateString($fieldPath, $this->namespace);
            $parameterPattern = RoutingUtility::deflateString($fieldPath, $this->namespace);
            $elements = explode('-', $parameterPattern);
            array_pop($elements);
            $parameterPattern = implode('-', $elements);
            $parameterPattern .= '__\d+';

            // @TODO: Here the behaviour changed. The whole functionality need to be tested
            $pathElements = explode('-', $fieldPath);
            $facetTypeToHandle = array_pop($pathElements);

            if (empty($facetTypeToHandle)) {
                continue;
            }
            foreach ($parameters as $parameterName => $parameterValue) {
                // Skip parameters that we don't care for
                if (!preg_match('/' . $parameterPattern . '/', $parameterName)) {
                    $parametersCombined[$parameterName] = $parameterValue;
                    continue;
                }

                if (!array_key_exists($combinedKey, $parametersCombined)) {
                    $parametersCombined[$combinedKey] = [];
                }

                $parameterNameNew = $parameterName;
                $parameterValueNew = $parameterValue;

                // Placeholder for cached URIs (type is the last part of the parameter value)
                if (substr($parameterValue, 0, 3) === '###') {
                    $facetFieldElements = explode(':', $parameterValue);
                    $facetField = array_pop($facetFieldElements);
                    $facetField = substr($facetField, 0, strlen($facetField) - 3);

                    $facetValue = null;
                    if (strpos($facetField, '%3A') !== false) {
                        [$facetField, $facetValue] = explode('%3A', $facetField, 2);
                    }

                    if ($facetField === $facetTypeToHandle) {
                        $parameterNameNew = $combinedKey;
                        if ($facetValue !== null) {
                            $parameterValueNew = $facetValue;
                        }
                    }
                } else {
                    [$facetField, $facetValue] = explode(':', $parameterValue, 2);
                    if (substr($facetValue, 0, mb_strlen($facetField) + 1) === $facetField . ':') {
                        [$facetField, $facetValue] = explode(':', $facetValue, 2);
                    }
                    if ($facetField === $facetTypeToHandle) {
                        $parameterNameNew = $combinedKey;
                        $parameterValueNew = $facetValue;
                    }
                }
                if (is_array($parametersCombined[$parameterNameNew])) {
                    $parametersCombined[$parameterNameNew][] = $parameterValueNew;
                } else {
                    $parametersCombined[$parameterNameNew] = $parameterValueNew;
                }
            }

            if (isset($parametersCombined[$combinedKey]) && is_array($parametersCombined[$combinedKey])) {
                $parametersCombined[$combinedKey] = $this->getRoutingService()->facetsToString(
                    $parametersCombined[$combinedKey]
                );
            }
        }

        return $parametersCombined;
    }

    /**
     * We need to convert our internal names by hand into hashes.
     *
     * This needs to be done, because we not exactly configure a path inside of the site configuration.
     * What we are configure is a placeholder contains information, what we should process
     *
     * @param Route $route
     * @param array $parameters
     * @return array
     */
    protected function replaceVariableWithHash(Route $route, array $parameters = []): array
    {
        $routPath = $this->configuration['routePath'];
        $pathElements = explode('/', $routPath);
        // Compiles path token are in reversed order
        $pathElements = array_reverse($pathElements);
        $routeArguments = $route->getArguments();
        $pathTokens = $route->compile()->getTokens();

        $keepVariables = [];

        $pathTokensCount = count($pathTokens);
        for ($i = 0; $i < $pathTokensCount; $i++) {
            // wee only looking for variables
            if ($pathTokens[$i][0] !== 'variable') {
                continue;
            }

            $pathVariable = $pathElements[$i];
            // Remove marker
            $pathVariable = substr($pathVariable, 1, strlen($pathVariable) - 1);
            $pathVariable = substr($pathVariable, 0, strlen($pathVariable) - 1);

            // Skip if we could not resolve the variable
            if (!isset($routeArguments[$pathVariable])) {
                continue;
            }

            $parameterName = RoutingUtility::deflateString(
                $routeArguments[$pathVariable],
                $this->namespace
            );

            // Skip processing if variable not listed inside of given parameters
            if (!isset($parameters[$parameterName])) {
                continue;
            }

            $parameters[$pathTokens[$i][3]] = $parameters[$parameterName];
            $keepVariables[] = $pathTokens[$i][3];
            unset($parameters[$parameterName]);
        }

        return $parameters;
    }

    /**
     * This method inflates some variables back, because if a route has deflated variables
     * they are used in the upcoming process.
     *
     * @see \TYPO3\CMS\Core\Routing\PageRouter::generateUri
     *
     * @param Route $variant
     * @param array $deflatedParameters
     * @return array
     */
    protected function inflateUnprocessedVariables(Route $variant, array $deflatedParameters): array
    {
        $mixedVariables = [];
        $variablesToHandle = [];
        foreach ($variant->getArguments() as $argumentKey => $argumentPath) {
            $variablesToHandle[] = RoutingUtility::deflateString($argumentPath, $this->namespace);
        }

        foreach ($deflatedParameters as $argumentKey => $argumentPath) {
            if (in_array($argumentKey, $variablesToHandle)) {
                $mixedVariables[$argumentKey] = $deflatedParameters[$argumentKey];
            } else {
                $elements = explode('__', $argumentKey);
                $elements[] = $deflatedParameters[$argumentKey];
                $data = $this->inflateQueryParams($elements);

                $mixedVariables = array_merge_recursive($mixedVariables, $data);
            }
        }

        return $mixedVariables;
    }

    /**
     * Inflate deflated query parameters
     *
     * @param array $elements
     * @return array
     */
    protected function inflateQueryParams(array $elements = []): array
    {
        $result = [];
        if (count($elements) > 2) {
            $key = array_shift($elements);
            $result[$key] = $this->inflateQueryParams($elements);
        } elseif (count($elements) == 2) {
            $result[$elements[0]] = $elements[1];
        }

        return $result;
    }

    /**
     * Deflate query parameters
     *
     * @param Route $route
     * @param array $parameters
     * @return array
     */
    protected function deflateParameters(Route $route, array $parameters): array
    {
        return $this->getVariableProcessor()->deflateNamespaceParameters(
            $parameters,
            $this->namespace,
            $route->getArguments()
        );
    }

    /**
     * @return RoutingService
     */
    protected function getRoutingService(): RoutingService
    {
        return GeneralUtility::makeInstance(
            RoutingService::class,
            $this->configuration['solr'],
            (string)$this->configuration['extensionKey']
        )->withPathArguments($this->configuration['_arguments']);
    }
}


1			<?php
2			namespace ApacheSolrForTypo3\Solr\Routing\Enhancer;
3
4			use ApacheSolrForTypo3\Solr\Routing\RoutingService;
5			use ApacheSolrForTypo3\Solr\Utility\RoutingUtility;
6			use TYPO3\CMS\Core\Routing\Enhancer\AbstractEnhancer;
7			use TYPO3\CMS\Core\Routing\Enhancer\RoutingEnhancerInterface;
8			use TYPO3\CMS\Core\Routing\Route;
9			use TYPO3\CMS\Core\Routing\RouteCollection;
10			use TYPO3\CMS\Core\Utility\GeneralUtility;
11
12			/*
13			* This file is part of the TYPO3 CMS project.
14			*
15			* It is free software; you can redistribute it and/or modify it under
16			* the terms of the GNU General Public License, either version 2
17			* of the License, or any later version.
18			*
19			* For the full copyright and license information, please read the
20			* LICENSE.txt file that was distributed with this source code.
21			*
22			* The TYPO3 project - inspiring people to share!
23			*/
24
25			class SolrFacetMaskAndCombineEnhancer extends AbstractEnhancer implements RoutingEnhancerInterface, SolrRouteEnhancerInterface
26			{
27			/**
28			* @var array
29			*/
30			protected $configuration;
31
32			/**
33			* @var string
34			*/
35			protected $namespace;
36
37			public function __construct(array $configuration)
38			{
39			$this->configuration = $configuration;
40			$this->namespace = $this->configuration['extensionKey'] ?? 'tx_solr';
41			}
42
43			/**
44			* {@inheritdoc}
45			*/
46			public function enhanceForMatching(RouteCollection $collection): void
47			{
48			/** @var Route $defaultPageRoute */
49			$defaultPageRoute = $collection->get('default');
50			$variant = $this->getVariant($defaultPageRoute, $this->configuration);
51			$collection->add(
52			'enhancer_' . $this->namespace . spl_object_hash($variant),
53			$variant
54			);
55			}
56
57			/**
58			* Builds a variant of a route based on the given configuration.
59			*
60			* @param Route $defaultPageRoute
61			* @param array $configuration
62			* @return Route
63			*/
64			protected function getVariant(Route $defaultPageRoute, array $configuration): Route
65			{
66			$arguments = $configuration['_arguments'] ?? [];
67			unset($configuration['_arguments']);
68
69			$variableProcessor = $this->getVariableProcessor();
70			$routePath = $this->modifyRoutePath($configuration['routePath']);
71			$routePath = $variableProcessor->deflateRoutePath($routePath, $this->namespace, $arguments);
72			$variant = clone $defaultPageRoute;
73			$variant->setPath(rtrim($variant->getPath(), '/') . '/' . ltrim($routePath, '/'));
74			$variant->addOptions(['_enhancer' => $this, '_arguments' => $arguments]);
75			$variant->setDefaults(
76			$variableProcessor->deflateKeys($this->configuration['defaults'] ?? [], $this->namespace, $arguments)
77			);
78			$this->applyRouteAspects($variant, $this->aspects ?? [], $this->namespace);
79			$this->applyRequirements($variant, $this->configuration['requirements'] ?? [], $this->namespace);
80			return $variant;
81			}
82
83			/**
84			* {@inheritdoc}
85			*/
86			public function enhanceForGeneration(RouteCollection $collection, array $parameters): void
87			{
88			// No parameter for this namespace given, so this route does not fit the requirements
89			if (!is_array($parameters[$this->namespace])) {
90			return;
91			}
92			/** @var Route $defaultPageRoute */
93			$defaultPageRoute = $collection->get('default');
94			$variant = $this->getVariant($defaultPageRoute, $this->configuration);
95			$compiledRoute = $variant->compile();
96			$deflatedParameters = $this->deflateParameters($variant, $parameters);
97			$deflatedParameters = $this->combineArrayParameters($deflatedParameters);
98			$deflatedParameters = $this->inflateUnprocessedVariables($variant, $deflatedParameters);
99			// TODO: Implode query parameters if configured!
100			$deflatedParameters = $this->replaceVariableWithHash($variant, $deflatedParameters);
101			$variant->setOption('deflatedParameters', $deflatedParameters);
102			$variables = array_flip($compiledRoute->getPathVariables());
103			$mergedParams = array_replace($variant->getDefaults(), $deflatedParameters);
104			// all params must be given, otherwise we exclude this variant
105			if (array_diff_key($variables, $mergedParams) !== []) {
106			return;
107			}
108
109			$collection->add('enhancer_' . $this->namespace . spl_object_hash($variant), $variant);
110			}
111
112			/**
113			* This method combine arguments into a single string
114			* It is possible to configure a path segment that contains more than one value.
115			* This method build one single string out of it.
116			*
117			* @param array $parameters
118			* @return array
119			*/
120			protected function combineArrayParameters(array $parameters = []): array
121			{
122			$parametersCombined = [];
123			foreach ($this->configuration['_arguments'] as $fieldName => $fieldPath) {
124			$combinedKey = RoutingUtility::deflateString($fieldPath, $this->namespace);
125			$parameterPattern = RoutingUtility::deflateString($fieldPath, $this->namespace);
126			$elements = explode('-', $parameterPattern);
127			array_pop($elements);
128			$parameterPattern = implode('-', $elements);
129			$parameterPattern .= '__\d+';
130
131			// @TODO: Here the behaviour changed. The whole functionality need to be tested
132			$pathElements = explode('-', $fieldPath);
133			$facetTypeToHandle = array_pop($pathElements);
134
135			if (empty($facetTypeToHandle)) {
136			continue;
137			}
138			foreach ($parameters as $parameterName => $parameterValue) {
139			// Skip parameters that we don't care for
140			if (!preg_match('/' . $parameterPattern . '/', $parameterName)) {
141			$parametersCombined[$parameterName] = $parameterValue;
142			continue;
143			}
144
145			if (!array_key_exists($combinedKey, $parametersCombined)) {
146			$parametersCombined[$combinedKey] = [];
147			}
148
149			$parameterNameNew = $parameterName;
150			$parameterValueNew = $parameterValue;
151
152			// Placeholder for cached URIs (type is the last part of the parameter value)
153			if (substr($parameterValue, 0, 3) === '###') {
154			$facetFieldElements = explode(':', $parameterValue);
155			$facetField = array_pop($facetFieldElements);
156			$facetField = substr($facetField, 0, strlen($facetField) - 3);
157
158			$facetValue = null;
159			if (strpos($facetField, '%3A') !== false) {
160			[$facetField, $facetValue] = explode('%3A', $facetField, 2);
161			}
162
163			if ($facetField === $facetTypeToHandle) {
164			$parameterNameNew = $combinedKey;
165			if ($facetValue !== null) {
166			$parameterValueNew = $facetValue;
167			}
168			}
169			} else {
170			[$facetField, $facetValue] = explode(':', $parameterValue, 2);
171			if (substr($facetValue, 0, mb_strlen($facetField) + 1) === $facetField . ':') {
172			[$facetField, $facetValue] = explode(':', $facetValue, 2);
173			}
174			if ($facetField === $facetTypeToHandle) {
175			$parameterNameNew = $combinedKey;
176			$parameterValueNew = $facetValue;
177			}
178			}
179			if (is_array($parametersCombined[$parameterNameNew])) {
180			$parametersCombined[$parameterNameNew][] = $parameterValueNew;
181			} else {
182			$parametersCombined[$parameterNameNew] = $parameterValueNew;
183			}
184			}
185
186			if (isset($parametersCombined[$combinedKey]) && is_array($parametersCombined[$combinedKey])) {
187			$parametersCombined[$combinedKey] = $this->getRoutingService()->facetsToString(
188			$parametersCombined[$combinedKey]
189			);
190			}
191			}
192
193			return $parametersCombined;
194			}
195
196			/**
197			* We need to convert our internal names by hand into hashes.
198			*
199			* This needs to be done, because we not exactly configure a path inside of the site configuration.
200			* What we are configure is a placeholder contains information, what we should process
201			*
202			* @param Route $route
203			* @param array $parameters
204			* @return array
205			*/
206			protected function replaceVariableWithHash(Route $route, array $parameters = []): array
207			{
208			$routPath = $this->configuration['routePath'];
209			$pathElements = explode('/', $routPath);
210			// Compiles path token are in reversed order
211			$pathElements = array_reverse($pathElements);
212			$routeArguments = $route->getArguments();
213			$pathTokens = $route->compile()->getTokens();
214
215			$keepVariables = [];
216
217			$pathTokensCount = count($pathTokens);
218			for ($i = 0; $i < $pathTokensCount; $i++) {
219			// wee only looking for variables
220			if ($pathTokens[$i][0] !== 'variable') {
221			continue;
222			}
223
224			$pathVariable = $pathElements[$i];
225			// Remove marker
226			$pathVariable = substr($pathVariable, 1, strlen($pathVariable) - 1);
227			$pathVariable = substr($pathVariable, 0, strlen($pathVariable) - 1);
228
229			// Skip if we could not resolve the variable
230			if (!isset($routeArguments[$pathVariable])) {
231			continue;
232			}
233
234			$parameterName = RoutingUtility::deflateString(
235			$routeArguments[$pathVariable],
236			$this->namespace
237			);
238
239			// Skip processing if variable not listed inside of given parameters
240			if (!isset($parameters[$parameterName])) {
241			continue;
242			}
243
244			$parameters[$pathTokens[$i][3]] = $parameters[$parameterName];
245			$keepVariables[] = $pathTokens[$i][3];
246			unset($parameters[$parameterName]);
247			}
248
249			return $parameters;
250			}
251
252			/**
253			* This method inflates some variables back, because if a route has deflated variables
254			* they are used in the upcoming process.
255			*
256			* @see \TYPO3\CMS\Core\Routing\PageRouter::generateUri
257			*
258			* @param Route $variant
259			* @param array $deflatedParameters
260			* @return array
261			*/
262			protected function inflateUnprocessedVariables(Route $variant, array $deflatedParameters): array
263			{
264			$mixedVariables = [];
265			$variablesToHandle = [];
266			foreach ($variant->getArguments() as $argumentKey => $argumentPath) {
267			$variablesToHandle[] = RoutingUtility::deflateString($argumentPath, $this->namespace);
268			}
269
270			foreach ($deflatedParameters as $argumentKey => $argumentPath) {
271			if (in_array($argumentKey, $variablesToHandle)) {
272			$mixedVariables[$argumentKey] = $deflatedParameters[$argumentKey];
273			} else {
274			$elements = explode('__', $argumentKey);
275			$elements[] = $deflatedParameters[$argumentKey];
276			$data = $this->inflateQueryParams($elements);
277
278			$mixedVariables = array_merge_recursive($mixedVariables, $data);
279			}
280			}
281
282			return $mixedVariables;
283			}
284
285			/**
286			* Inflate deflated query parameters
287			*
288			* @param array $elements
289			* @return array
290			*/
291			protected function inflateQueryParams(array $elements = []): array
292			{
293			$result = [];
294			if (count($elements) > 2) {
295			$key = array_shift($elements);
296			$result[$key] = $this->inflateQueryParams($elements);
297			} elseif (count($elements) == 2) {
298			$result[$elements[0]] = $elements[1];
299			}
300
301			return $result;
302			}
303
304			/**
305			* Deflate query parameters
306			*
307			* @param Route $route
308			* @param array $parameters
309			* @return array
310			*/
311			protected function deflateParameters(Route $route, array $parameters): array
312			{
313			return $this->getVariableProcessor()->deflateNamespaceParameters(
314			$parameters,
315			$this->namespace,
316			$route->getArguments()
317			);
318			}
319
320			/**
321			* @return RoutingService
322			*/
323			protected function getRoutingService(): RoutingService
324			{
325			return GeneralUtility::makeInstance(
326			RoutingService::class,
327			$this->configuration['solr'],
328			(string)$this->configuration['extensionKey']
329			)->withPathArguments($this->configuration['_arguments']);
330			}
331			}
332

TYPO3-Solr / ext-solr

Pull Request — master (#2755)

combineArrayParameters() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like