PcreCompiler::hexdec() - Code Metrics - Inspection of "Enable testing on PHP 7.4 in .travis.yml" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — php74_support_25 ( d359d4 )

unknown

created 2020-04-14 10:41 UTC

PcreCompiler::hexdec() A

↳ Parent: PcreCompiler

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
nc	2
nop	1
dl	0
loc	8
rs	10
c	0
b	0
f	0

<?php

/**
 * File containing the PcreCompiler 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\Publish\Core\Persistence\TransformationProcessor;

use eZ\Publish\Core\Persistence\Utf8Converter;
use eZ\Publish\Core\Persistence\TransformationProcessor;
use RuntimeException;

/**
 * Compiles the AST of parsed transformation rules into a set of PCRE replace
 * regular expressions.
 */
class PcreCompiler
{
    /**
     * Class for converting UTF-8 characters.
     *
     * @var \eZ\Publish\Core\Persistence\Utf8Converter
     */
    protected $converter;

    /**
     * Construct from UTF8Converter.
     *
     * @param \eZ\Publish\Core\Persistence\Utf8Converter $converter
     */
    public function __construct(Utf8Converter $converter)
    {
        $this->converter = $converter;
    }

    /**
     * Compile AST into a set of regular expressions.
     *
     * The returned array contains a set of regular expressions and their
     * replacement callbacks. The regular expressions can then be applied to
     * strings to executed the transformations.
     *
     * @param array $ast
     *
     * @return array
     */
    public function compile(array $ast)
    {
        $transformations = [];

        foreach ($ast as $section => $rules) {
            foreach ($rules as $rule) {
                $transformations[$section][] = $this->compileRule($rule);
            }
        }

        return $transformations;
    }

    /**
     * Compiles a single rule.
     *
     * @param array $rule
     *
     * @return array
     */
    protected function compileRule(array $rule)
    {
        switch ($rule['type']) {
            case TransformationProcessor::T_MAP:
                return $this->compileMap($rule);

            case TransformationProcessor::T_REPLACE:
                return $this->compileReplace($rule);

            case TransformationProcessor::T_TRANSPOSE:
                return $this->compileTranspose($rule);

            case TransformationProcessor::T_TRANSPOSE_MODULO:
                return $this->compileTransposeModulo($rule);

            default:
                throw new RuntimeException('Unknown rule type: ' . $rule['type']);
        }
    }

    /**
     * Compile map rule.
     *
     * @param array $rule
     *
     * @return array
     */
    protected function compileMap(array $rule)
    {
        return [
            'regexp' => '(' . preg_quote($this->compileCharacter($rule['data']['src'])) . ')us',
            'callback' => $this->compileTargetCharacter($rule['data']['dest']),
        ];
    }

    /**
     * Compile replace rule.
     *
     * @param array $rule
     *
     * @return array
     */
    protected function compileReplace(array $rule)
    {
        return [
            'regexp' => '([' .
                preg_quote($this->compileCharacter($rule['data']['srcStart'])) . '-' .
                preg_quote($this->compileCharacter($rule['data']['srcEnd'])) .
                '])us',
            'callback' => $this->compileTargetCharacter($rule['data']['dest']),
        ];
    }

    /**
     * Compile transpose rule.
     *
     * @param array $rule
     *
     * @return array
     */
    protected function compileTranspose(array $rule)
    {
        return [
            'regexp' => '([' .
                preg_quote($this->compileCharacter($rule['data']['srcStart'])) . '-' .
                preg_quote($this->compileCharacter($rule['data']['srcEnd'])) .
                '])us',
            'callback' => $this->getTransposeClosure($rule['data']['op'], $rule['data']['dest']),
        ];
    }

    /**
     * Compile transpose modulo rule.
     *
     * @param array $rule
     *
     * @return array
     */
    protected function compileTransposeModulo(array $rule)
    {
        return [
            'regexp' => '([' .
                preg_quote(
                    $this->getModuloCharRange(
                        $this->compileCharacter($rule['data']['srcStart']),
                        $this->compileCharacter($rule['data']['srcEnd']),
                        $rule['data']['modulo']
                    )
                ) .
                '])us',
            'callback' => $this->getTransposeClosure($rule['data']['op'], $rule['data']['dest']),
        ];
    }

    /**
     * Get string with all characters defined by parameters.
     *
     * Returns a string containing all UTF-8 characters starting with the
     * specified $start character up to the $end character with the step size
     * defined in $modulo.
     *
     * @param string $start
     * @param string $end
     * @param string $modulo
     *
     * @return string
     */
    protected function getModuloCharRange($start, $end, $modulo)
    {
        $start = $this->converter->toUnicodeCodepoint($start);
        $end = $this->converter->toUnicodeCodepoint($end);
        $modulo = hexdec($modulo);

        $chars = '';
        for ($start; $start <= $end; $start += $modulo) {
            $chars .= $this->converter->toUTF8Character($start);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }

        return $chars;
    }

    /**
     * Returns a closure which modifies the provided character by the given
     * value.
     *
     * @param string $operator
     * @param string $value
     *
     * @return callback
     */
    protected function getTransposeClosure($operator, $value)
    {
        $value = $this->hexdec($value) * ($operator === '-' ? -1 : 1);
        $converter = $this->converter;

        return function ($matches) use ($value, $converter) {
            return $converter->toUTF8Character(
                $converter->toUnicodeCodepoint($matches[0]) + $value
            );
        };
    }

    /**
     * Compile target into a closure, which can be used by
     * preg_replace_callback.
     *
     * @param string $char
     *
     * @return callback
     */
    protected function compileTargetCharacter($char)
    {
        switch (true) {

            case $char === 'remove':
                return function ($matches) {

                    return '';
                };

            case $char === 'keep':
                return function ($matches) {
                    return $matches[0];
                };

            case preg_match('("(?:[^\\\\"]+|\\\\\\\\|\\\\\'|\\\\")*?")', $char):
                $string = str_replace(
                    ['\\\\', '\\"', "\\'"],
                    ['\\', '"', "'"],
                    substr($char, 1, -1)
                );

                return function ($matches) use ($string) {

                    return $string;
                };

            default:
                $char = $this->compileCharacter($char);

                return function ($matches) use ($char) {

                    return $char;
                };
        }
    }

    /**
     * Compile a single source character definition into a plain UTF-8 character.
     *
     * Handles the two formats from the possible character definitions:
     *  - U+xxxx : Unicode value in hexadecimal
     *  - xx: Ascii value in hexadecimal
     *
     * @param string $char
     *
     * @return string
     */
    protected function compileCharacter($char)
    {
        switch (true) {

            case preg_match('(^U\\+[0-9a-fA-F]{4}$)', $char):
                return $this->converter->toUTF8Character(hexdec(substr($char, 2)));

            case preg_match('(^[0-9a-fA-F]{2}$)', $char):
                return chr(hexdec($char));

            default:
                throw new RuntimeException("Invalid character definition: $char");
        }
    }

    /**
     * Converts a hexadecimal string to a decimal number.
     *
     * In compare to standard hexdec function it will ignore any non-hexadecimal characters
     */
    private function hexdec(?string $value): int
    {
        if ($value === null) {
            return 0;
        }

        return hexdec(preg_replace('/[^[:xdigit:]]/', '', (string)$value));
    }
}


1			<?php
2
3			/**
4			* File containing the PcreCompiler 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\Publish\Core\Persistence\TransformationProcessor;
10
11			use eZ\Publish\Core\Persistence\Utf8Converter;
12			use eZ\Publish\Core\Persistence\TransformationProcessor;
13			use RuntimeException;
14
15			/**
16			* Compiles the AST of parsed transformation rules into a set of PCRE replace
17			* regular expressions.
18			*/
19			class PcreCompiler
20			{
21			/**
22			* Class for converting UTF-8 characters.
23			*
24			* @var \eZ\Publish\Core\Persistence\Utf8Converter
25			*/
26			protected $converter;
27
28			/**
29			* Construct from UTF8Converter.
30			*
31			* @param \eZ\Publish\Core\Persistence\Utf8Converter $converter
32			*/
33			public function __construct(Utf8Converter $converter)
34			{
35			$this->converter = $converter;
36			}
37
38			/**
39			* Compile AST into a set of regular expressions.
40			*
41			* The returned array contains a set of regular expressions and their
42			* replacement callbacks. The regular expressions can then be applied to
43			* strings to executed the transformations.
44			*
45			* @param array $ast
46			*
47			* @return array
48			*/
49			public function compile(array $ast)
50			{
51			$transformations = [];
52
53			foreach ($ast as $section => $rules) {
54			foreach ($rules as $rule) {
55			$transformations[$section][] = $this->compileRule($rule);
56			}
57			}
58
59			return $transformations;
60			}
61
62			/**
63			* Compiles a single rule.
64			*
65			* @param array $rule
66			*
67			* @return array
68			*/
69			protected function compileRule(array $rule)
70			{
71			switch ($rule['type']) {
72			case TransformationProcessor::T_MAP:
73			return $this->compileMap($rule);
74
75			case TransformationProcessor::T_REPLACE:
76			return $this->compileReplace($rule);
77
78			case TransformationProcessor::T_TRANSPOSE:
79			return $this->compileTranspose($rule);
80
81			case TransformationProcessor::T_TRANSPOSE_MODULO:
82			return $this->compileTransposeModulo($rule);
83
84			default:
85			throw new RuntimeException('Unknown rule type: ' . $rule['type']);
86			}
87			}
88
89			/**
90			* Compile map rule.
91			*
92			* @param array $rule
93			*
94			* @return array
95			*/
96			protected function compileMap(array $rule)
97			{
98			return [
99			'regexp' => '(' . preg_quote($this->compileCharacter($rule['data']['src'])) . ')us',
100			'callback' => $this->compileTargetCharacter($rule['data']['dest']),
101			];
102			}
103
104			/**
105			* Compile replace rule.
106			*
107			* @param array $rule
108			*
109			* @return array
110			*/
111			protected function compileReplace(array $rule)
112			{
113			return [
114			'regexp' => '([' .
115			preg_quote($this->compileCharacter($rule['data']['srcStart'])) . '-' .
116			preg_quote($this->compileCharacter($rule['data']['srcEnd'])) .
117			'])us',
118			'callback' => $this->compileTargetCharacter($rule['data']['dest']),
119			];
120			}
121
122			/**
123			* Compile transpose rule.
124			*
125			* @param array $rule
126			*
127			* @return array
128			*/
129			protected function compileTranspose(array $rule)
130			{
131			return [
132			'regexp' => '([' .
133			preg_quote($this->compileCharacter($rule['data']['srcStart'])) . '-' .
134			preg_quote($this->compileCharacter($rule['data']['srcEnd'])) .
135			'])us',
136			'callback' => $this->getTransposeClosure($rule['data']['op'], $rule['data']['dest']),
137			];
138			}
139
140			/**
141			* Compile transpose modulo rule.
142			*
143			* @param array $rule
144			*
145			* @return array
146			*/
147			protected function compileTransposeModulo(array $rule)
148			{
149			return [
150			'regexp' => '([' .
151			preg_quote(
152			$this->getModuloCharRange(
153			$this->compileCharacter($rule['data']['srcStart']),
154			$this->compileCharacter($rule['data']['srcEnd']),
155			$rule['data']['modulo']
156			)
157			) .
158			'])us',
159			'callback' => $this->getTransposeClosure($rule['data']['op'], $rule['data']['dest']),
160			];
161			}
162
163			/**
164			* Get string with all characters defined by parameters.
165			*
166			* Returns a string containing all UTF-8 characters starting with the
167			* specified $start character up to the $end character with the step size
168			* defined in $modulo.
169			*
170			* @param string $start
171			* @param string $end
172			* @param string $modulo
173			*
174			* @return string
175			*/
176			protected function getModuloCharRange($start, $end, $modulo)
177			{
178			$start = $this->converter->toUnicodeCodepoint($start);
179			$end = $this->converter->toUnicodeCodepoint($end);
180			$modulo = hexdec($modulo);
181
182			$chars = '';
183			for ($start; $start <= $end; $start += $modulo) {
184			$chars .= $this->converter->toUTF8Character($start);
			0 ignored issues – show Bug introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report It seems like `$start` can also be of type `double` or `false`; however, `eZ\Publish\Core\Persiste...rter::toUTF8Character()` does only seem to accept `integer`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
185			}
186
187			return $chars;
188			}
189
190			/**
191			* Returns a closure which modifies the provided character by the given
192			* value.
193			*
194			* @param string $operator
195			* @param string $value
196			*
197			* @return callback
198			*/
199			protected function getTransposeClosure($operator, $value)
200			{
201			$value = $this->hexdec($value) * ($operator === '-' ? -1 : 1);
202			$converter = $this->converter;
203
204			return function ($matches) use ($value, $converter) {
205			return $converter->toUTF8Character(
206			$converter->toUnicodeCodepoint($matches[0]) + $value
207			);
208			};
209			}
210
211			/**
212			* Compile target into a closure, which can be used by
213			* preg_replace_callback.
214			*
215			* @param string $char
216			*
217			* @return callback
218			*/
219			protected function compileTargetCharacter($char)
220			{
221			switch (true) {
			0 ignored issues – show Bug Best Practice introduced 2017-04-18 15:26 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `preg_match('("(?:[^\\\\"...\\'\|\\\\")*?")', $char)` of type `integer` to the boolean `true`. If you are specifically checking for non-zero, consider using something more explicit like `> 0` or `!== 0` instead. Loading history...
222			case $char === 'remove':
223			return function ($matches) {
			0 ignored issues – show Unused Code introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report The parameter `$matches` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
224			return '';
225			};
226
227			case $char === 'keep':
228			return function ($matches) {
229			return $matches[0];
230			};
231
232			case preg_match('("(?:[^\\\\"]+\|\\\\\\\\\|\\\\\'\|\\\\")*?")', $char):
233			$string = str_replace(
234			['\\\\', '\\"', "\\'"],
235			['\\', '"', "'"],
236			substr($char, 1, -1)
237			);
238
239			return function ($matches) use ($string) {
			0 ignored issues – show Unused Code introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report The parameter `$matches` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
240			return $string;
241			};
242
243			default:
244			$char = $this->compileCharacter($char);
245
246			return function ($matches) use ($char) {
			0 ignored issues – show Unused Code introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report The parameter `$matches` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
247			return $char;
248			};
249			}
250			}
251
252			/**
253			* Compile a single source character definition into a plain UTF-8 character.
254			*
255			* Handles the two formats from the possible character definitions:
256			* - U+xxxx : Unicode value in hexadecimal
257			* - xx: Ascii value in hexadecimal
258			*
259			* @param string $char
260			*
261			* @return string
262			*/
263			protected function compileCharacter($char)
264			{
265			switch (true) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `preg_match('(^U\\+[0-9a-fA-F]{4}$)', $char)` of type `integer` to the boolean `true`. If you are specifically checking for non-zero, consider using something more explicit like `> 0` or `!== 0` instead. Loading history... Bug Best Practice introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `preg_match('(^[0-9a-fA-F]{2}$)', $char)` of type `integer` to the boolean `true`. If you are specifically checking for non-zero, consider using something more explicit like `> 0` or `!== 0` instead. Loading history...
266			case preg_match('(^U\\+[0-9a-fA-F]{4}$)', $char):
267			return $this->converter->toUTF8Character(hexdec(substr($char, 2)));
268
269			case preg_match('(^[0-9a-fA-F]{2}$)', $char):
270			return chr(hexdec($char));
271
272			default:
273			throw new RuntimeException("Invalid character definition: $char");
274			}
275			}
276
277			/**
278			* Converts a hexadecimal string to a decimal number.
279			*
280			* In compare to standard hexdec function it will ignore any non-hexadecimal characters
281			*/
282			private function hexdec(?string $value): int
283			{
284			if ($value === null) {
285			return 0;
286			}
287
288			return hexdec(preg_replace('/[^[:xdigit:]]/', '', (string)$value));
289			}
290			}
291

ezsystems / ezpublish-kernel

Push — php74_support_25 ( d359d4 )

PcreCompiler::hexdec() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like