WsdlToPhp\PackageGenerator\File\Validation\PatternRule

Complexity

Total Complexity

12

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	name()	0	3	1
A	getArrayExceptionMessageOnTestFailure()	0	5	1
A	exceptionMessageOnTestFailure()	0	13	3
A	testConditions()	0	19	4
A	valueToRegularExpression()	0	13	3

<?php

declare(strict_types=1);

namespace WsdlToPhp\PackageGenerator\File\Validation;

/**
 * @see https://www.w3.org/TR/xmlschema-2/#rf-pattern
 * Validation Rule: pattern valid
 * A literal in a ·lexical space· is facet-valid with respect to ·pattern· if:
 *  - 1 the literal is among the set of character sequences denoted by the ·regular expression· specified in {value}.
 */
final class PatternRule extends AbstractRule
{
    public const NAME = 'pattern';

    public function name(): string
    {
        return self::NAME;
    }

    public function testConditions(string $parameterName, $value, bool $itemType = false): string
    {
        if ($itemType || !$this->getAttribute()->isArray()) {
            $test = sprintf(
                ($itemType ? '' : '!is_null($%1$s) && ').'!preg_match(\'/%2$s/\', $%1$s)',
                $parameterName,
                self::valueToRegularExpression($value)
            );
        } else {
            $this->addArrayValidationMethod($parameterName, $value);
            $test = sprintf(
                '\'\' !== (%s = self::%s($%s))',
                $this->getArrayErrorMessageVariableName($parameterName),
                $this->getValidationMethodName($parameterName),
                $parameterName
            );
        }

        return $test;
    }

    public function exceptionMessageOnTestFailure(string $parameterName, $value, bool $itemType = false): string
    {
        if ($itemType || !$this->getAttribute()->isArray()) {
            $message = sprintf(
                'sprintf(\'Invalid value %%s, please provide a literal that is among the set of character sequences denoted by the regular expression /%s/\', var_export($%s, true))',
                self::valueToRegularExpression($value),
                $parameterName
            );
        } else {
            $message = $this->getArrayErrorMessageVariableName($parameterName);
        }

        return $message;
    }

    public static function valueToRegularExpression($value): string
    {
        return implode(
            '|',
            array_map(
                static function ($value) {
                    return addcslashes($value, '\'\\/');
                },
                array_map(
                    static function ($value) {
                        return empty($value) ? '^$' : $value;
                    },
                    array_map('trim', is_array($value) ? $value : [$value])
                )
            )
        );
    }

    protected function getArrayExceptionMessageOnTestFailure($value): string
    {
        return sprintf(
            'Invalid value(s) %%s, please provide literals that are among the set of character sequences denoted by the regular expression /%s/\'',
            stripcslashes(self::valueToRegularExpression($value)),
        );
    }
}