SolrFacetMaskAndCombineEnhancer::getVariant() - 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-16 11:38 UTC

SolrFacetMaskAndCombineEnhancer::getVariant() A

↳ Parent: SolrFacetMaskAndCombineEnhancer

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	13
dl	0
loc	17
ccs	0
cts	16
cp	0
rs	9.8333
c	0
b	0
f	0
cc	1
nc	1
nop	2
crap	2

<?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 ($diff = 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 = [];

        for ($i = 0; $i < count($pathTokens); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            // 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 ($diff = array_diff_key($variables, $mergedParams)) {
			0 ignored issues – show Unused Code introduced 2020-10-08 07:28 UTC by Report Bug Copy Issue Report The assignment to `$diff` is dead and can be removed. Loading history...
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			for ($i = 0; $i < count($pathTokens); $i++) {
			0 ignored issues – show Performance Best Practice introduced 2020-10-08 07:28 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
218			// wee only looking for variables
219			if ($pathTokens[$i][0] !== 'variable') {
220			continue;
221			}
222
223			$pathVariable = $pathElements[$i];
224			// Remove marker
225			$pathVariable = substr($pathVariable, 1, strlen($pathVariable) - 1);
226			$pathVariable = substr($pathVariable, 0, strlen($pathVariable) - 1);
227
228			// Skip if we could not resolve the variable
229			if (!isset($routeArguments[$pathVariable])) {
230			continue;
231			}
232
233			$parameterName = RoutingUtility::deflateString(
234			$routeArguments[$pathVariable],
235			$this->namespace
236			);
237
238			// Skip processing if variable not listed inside of given parameters
239			if (!isset($parameters[$parameterName])) {
240			continue;
241			}
242
243			$parameters[$pathTokens[$i][3]] = $parameters[$parameterName];
244			$keepVariables[] = $pathTokens[$i][3];
245			unset($parameters[$parameterName]);
246			}
247
248			return $parameters;
249			}
250
251			/**
252			* This method inflates some variables back, because if a route has deflated variables
253			* they are used in the upcoming process.
254			*
255			* @see \TYPO3\CMS\Core\Routing\PageRouter::generateUri
256			*
257			* @param Route $variant
258			* @param array $deflatedParameters
259			* @return array
260			*/
261			protected function inflateUnprocessedVariables(Route $variant, array $deflatedParameters): array
262			{
263			$mixedVariables = [];
264			$variablesToHandle = [];
265			foreach ($variant->getArguments() as $argumentKey => $argumentPath) {
266			$variablesToHandle[] = RoutingUtility::deflateString($argumentPath, $this->namespace);
267			}
268
269			foreach ($deflatedParameters as $argumentKey => $argumentPath) {
270			if (in_array($argumentKey, $variablesToHandle)) {
271			$mixedVariables[$argumentKey] = $deflatedParameters[$argumentKey];
272			} else {
273			$elements = explode('__', $argumentKey);
274			$elements[] = $deflatedParameters[$argumentKey];
275			$data = $this->inflateQueryParams($elements);
276
277			$mixedVariables = array_merge_recursive($mixedVariables, $data);
278			}
279			}
280
281			return $mixedVariables;
282			}
283
284			/**
285			* Inflate deflated query parameters
286			*
287			* @param array $elements
288			* @return array
289			*/
290			protected function inflateQueryParams(array $elements = []): array
291			{
292			$result = [];
293			if (count($elements) > 2) {
294			$key = array_shift($elements);
295			$result[$key] = $this->inflateQueryParams($elements);
296			} elseif (count($elements) == 2) {
297			$result[$elements[0]] = $elements[1];
298			}
299
300			return $result;
301			}
302
303			/**
304			* Deflate query parameters
305			*
306			* @param Route $route
307			* @param array $parameters
308			* @return array
309			*/
310			protected function deflateParameters(Route $route, array $parameters): array
311			{
312			return $this->getVariableProcessor()->deflateNamespaceParameters(
313			$parameters,
314			$this->namespace,
315			$route->getArguments()
316			);
317			}
318
319			/**
320			* @return RoutingService
321			*/
322			protected function getRoutingService(): RoutingService
323			{
324			return GeneralUtility::makeInstance(
325			RoutingService::class,
326			$this->configuration['solr'],
327			(string)$this->configuration['extensionKey']
328			)->withPathArguments($this->configuration['_arguments']);
329			}
330			}
331

TYPO3-Solr / ext-solr

Pull Request — master (#2755)

SolrFacetMaskAndCombineEnhancer::getVariant() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like