eZ\Publish\Core\Persistence\TransformationProcessor\PcreCompiler

Complexity

Total Complexity

26

Size/Duplication

Total Lines	272
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	compile()	0	12	3
A	compileRule()	0	19	5
A	compileMap()	0	7	1
A	compileTransposeModulo()	0	15	1
A	getModuloCharRange()	0	13	2
A	getTransposeClosure()	0	11	2
A	compileTargetCharacter()	0	32	4
A	compileCharacter()	0	13	3
A	compileReplace()	0	10	1
A	compileTranspose()	0	10	1
A	hexdec()	0	8	2

<?php

/**
 * @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);

It seems like $start can also be of type double or false; however, eZ\Publish\Core\Persistence\Utf8Converter::toUTF8Character() does only seem to accept integer, maybe add an additional type check?

        }

        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) {

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.

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

The parameter $matches is not used and could be removed.

                    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) {

The parameter $matches is not used and could be removed.

                    return $string;
                };

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

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

The parameter $matches is not used and could be removed.

                    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) {

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.

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.

            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 comparison 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));
    }
}