function AnnotationParser::parseRequirements

@psalm-return list<Metadata>

Throws

InvalidVersionOperatorException

2 calls to AnnotationParser::parseRequirements()

AnnotationParser::forClass in vendor/phpunit/phpunit/src/Metadata/Parser/AnnotationParser.php

@psalm-param class-string $className

AnnotationParser::forMethod in vendor/phpunit/phpunit/src/Metadata/Parser/AnnotationParser.php

@psalm-param class-string $className @psalm-param non-empty-string $methodName

File

vendor/phpunit/phpunit/src/Metadata/Parser/AnnotationParser.php, line 447

Class

AnnotationParser

@no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit

Namespace

PHPUnit\Metadata\Parser

Code

private function parseRequirements(array $requirements, string $level) : array {
    $result = [];
    if (!empty($requirements['PHP'])) {
        $versionRequirement = new ComparisonRequirement($requirements['PHP']['version'], new VersionComparisonOperator(empty($requirements['PHP']['operator']) ? '>=' : $requirements['PHP']['operator']));
        if ($level === 'class') {
            $result[] = Metadata::requiresPhpOnClass($versionRequirement);
        }
        else {
            $result[] = Metadata::requiresPhpOnMethod($versionRequirement);
        }
    }
    elseif (!empty($requirements['PHP_constraint'])) {
        $versionRequirement = new ConstraintRequirement($requirements['PHP_constraint']['constraint']);
        if ($level === 'class') {
            $result[] = Metadata::requiresPhpOnClass($versionRequirement);
        }
        else {
            $result[] = Metadata::requiresPhpOnMethod($versionRequirement);
        }
    }
    if (!empty($requirements['extensions'])) {
        foreach ($requirements['extensions'] as $extension) {
            if (isset($requirements['extension_versions'][$extension])) {
                continue;
            }
            if ($level === 'class') {
                $result[] = Metadata::requiresPhpExtensionOnClass($extension, null);
            }
            else {
                $result[] = Metadata::requiresPhpExtensionOnMethod($extension, null);
            }
        }
    }
    if (!empty($requirements['extension_versions'])) {
        foreach ($requirements['extension_versions'] as $extension => $version) {
            $versionRequirement = new ComparisonRequirement($version['version'], new VersionComparisonOperator(empty($version['operator']) ? '>=' : $version['operator']));
            if ($level === 'class') {
                $result[] = Metadata::requiresPhpExtensionOnClass($extension, $versionRequirement);
            }
            else {
                $result[] = Metadata::requiresPhpExtensionOnMethod($extension, $versionRequirement);
            }
        }
    }
    if (!empty($requirements['PHPUnit'])) {
        $versionRequirement = new ComparisonRequirement($requirements['PHPUnit']['version'], new VersionComparisonOperator(empty($requirements['PHPUnit']['operator']) ? '>=' : $requirements['PHPUnit']['operator']));
        if ($level === 'class') {
            $result[] = Metadata::requiresPhpunitOnClass($versionRequirement);
        }
        else {
            $result[] = Metadata::requiresPhpunitOnMethod($versionRequirement);
        }
    }
    elseif (!empty($requirements['PHPUnit_constraint'])) {
        $versionRequirement = new ConstraintRequirement($requirements['PHPUnit_constraint']['constraint']);
        if ($level === 'class') {
            $result[] = Metadata::requiresPhpunitOnClass($versionRequirement);
        }
        else {
            $result[] = Metadata::requiresPhpunitOnMethod($versionRequirement);
        }
    }
    if (!empty($requirements['OSFAMILY'])) {
        if ($level === 'class') {
            $result[] = Metadata::requiresOperatingSystemFamilyOnClass($requirements['OSFAMILY']);
        }
        else {
            $result[] = Metadata::requiresOperatingSystemFamilyOnMethod($requirements['OSFAMILY']);
        }
    }
    if (!empty($requirements['OS'])) {
        if ($level === 'class') {
            $result[] = Metadata::requiresOperatingSystemOnClass($requirements['OS']);
        }
        else {
            $result[] = Metadata::requiresOperatingSystemOnMethod($requirements['OS']);
        }
    }
    if (!empty($requirements['functions'])) {
        foreach ($requirements['functions'] as $function) {
            $pieces = explode('::', $function);
            if (count($pieces) === 2) {
                if ($level === 'class') {
                    $result[] = Metadata::requiresMethodOnClass($pieces[0], $pieces[1]);
                }
                else {
                    $result[] = Metadata::requiresMethodOnMethod($pieces[0], $pieces[1]);
                }
            }
            elseif ($level === 'class') {
                $result[] = Metadata::requiresFunctionOnClass($function);
            }
            else {
                $result[] = Metadata::requiresFunctionOnMethod($function);
            }
        }
    }
    if (!empty($requirements['setting'])) {
        foreach ($requirements['setting'] as $setting => $value) {
            if ($level === 'class') {
                $result[] = Metadata::requiresSettingOnClass($setting, $value);
            }
            else {
                $result[] = Metadata::requiresSettingOnMethod($setting, $value);
            }
        }
    }
    return $result;
}