function AttributeParser::forClass

@psalm-param class-string $className

Overrides Parser::forClass

File

vendor/phpunit/phpunit/src/Metadata/Parser/AttributeParser.php, line 87

Class

AttributeParser

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

Namespace

PHPUnit\Metadata\Parser

Code

public function forClass(string $className) : MetadataCollection {
    assert(class_exists($className));
    $result = [];
    foreach ((new ReflectionClass($className))->getAttributes() as $attribute) {
        if (!str_starts_with($attribute->getName(), 'PHPUnit\\Framework\\Attributes\\')) {
            continue;
        }
        if (!class_exists($attribute->getName())) {
            continue;
        }
        $attributeInstance = $attribute->newInstance();
        switch ($attribute->getName()) {
            case BackupGlobals::class:
                assert($attributeInstance instanceof BackupGlobals);
                $result[] = Metadata::backupGlobalsOnClass($attributeInstance->enabled());
                break;
            case BackupStaticProperties::class:
                assert($attributeInstance instanceof BackupStaticProperties);
                $result[] = Metadata::backupStaticPropertiesOnClass($attributeInstance->enabled());
                break;
            case CoversClass::class:
                assert($attributeInstance instanceof CoversClass);
                $result[] = Metadata::coversClass($attributeInstance->className());
                break;
            case CoversFunction::class:
                assert($attributeInstance instanceof CoversFunction);
                $result[] = Metadata::coversFunction($attributeInstance->functionName());
                break;
            case CoversNothing::class:
                $result[] = Metadata::coversNothingOnClass();
                break;
            case DoesNotPerformAssertions::class:
                $result[] = Metadata::doesNotPerformAssertionsOnClass();
                break;
            case ExcludeGlobalVariableFromBackup::class:
                assert($attributeInstance instanceof ExcludeGlobalVariableFromBackup);
                $result[] = Metadata::excludeGlobalVariableFromBackupOnClass($attributeInstance->globalVariableName());
                break;
            case ExcludeStaticPropertyFromBackup::class:
                assert($attributeInstance instanceof ExcludeStaticPropertyFromBackup);
                $result[] = Metadata::excludeStaticPropertyFromBackupOnClass($attributeInstance->className(), $attributeInstance->propertyName());
                break;
            case Group::class:
                assert($attributeInstance instanceof Group);
                $result[] = Metadata::groupOnClass($attributeInstance->name());
                break;
            case Large::class:
                $result[] = Metadata::groupOnClass('large');
                break;
            case Medium::class:
                $result[] = Metadata::groupOnClass('medium');
                break;
            case IgnoreClassForCodeCoverage::class:
                assert($attributeInstance instanceof IgnoreClassForCodeCoverage);
                $result[] = Metadata::ignoreClassForCodeCoverage($attributeInstance->className());
                break;
            case IgnoreDeprecations::class:
                assert($attributeInstance instanceof IgnoreDeprecations);
                $result[] = Metadata::ignoreDeprecationsOnClass();
                break;
            case IgnoreMethodForCodeCoverage::class:
                assert($attributeInstance instanceof IgnoreMethodForCodeCoverage);
                $result[] = Metadata::ignoreMethodForCodeCoverage($attributeInstance->className(), $attributeInstance->methodName());
                break;
            case IgnoreFunctionForCodeCoverage::class:
                assert($attributeInstance instanceof IgnoreFunctionForCodeCoverage);
                $result[] = Metadata::ignoreFunctionForCodeCoverage($attributeInstance->functionName());
                break;
            case PreserveGlobalState::class:
                assert($attributeInstance instanceof PreserveGlobalState);
                $result[] = Metadata::preserveGlobalStateOnClass($attributeInstance->enabled());
                break;
            case RequiresMethod::class:
                assert($attributeInstance instanceof RequiresMethod);
                $result[] = Metadata::requiresMethodOnClass($attributeInstance->className(), $attributeInstance->methodName());
                break;
            case RequiresFunction::class:
                assert($attributeInstance instanceof RequiresFunction);
                $result[] = Metadata::requiresFunctionOnClass($attributeInstance->functionName());
                break;
            case RequiresOperatingSystem::class:
                assert($attributeInstance instanceof RequiresOperatingSystem);
                $result[] = Metadata::requiresOperatingSystemOnClass($attributeInstance->regularExpression());
                break;
            case RequiresOperatingSystemFamily::class:
                assert($attributeInstance instanceof RequiresOperatingSystemFamily);
                $result[] = Metadata::requiresOperatingSystemFamilyOnClass($attributeInstance->operatingSystemFamily());
                break;
            case RequiresPhp::class:
                assert($attributeInstance instanceof RequiresPhp);
                $result[] = Metadata::requiresPhpOnClass(ConstraintRequirement::from($attributeInstance->versionRequirement()));
                break;
            case RequiresPhpExtension::class:
                assert($attributeInstance instanceof RequiresPhpExtension);
                $versionConstraint = null;
                $versionRequirement = $attributeInstance->versionRequirement();
                if ($versionRequirement !== null) {
                    $versionConstraint = ConstraintRequirement::from($versionRequirement);
                }
                $result[] = Metadata::requiresPhpExtensionOnClass($attributeInstance->extension(), $versionConstraint);
                break;
            case RequiresPhpunit::class:
                assert($attributeInstance instanceof RequiresPhpunit);
                $result[] = Metadata::requiresPhpunitOnClass(ConstraintRequirement::from($attributeInstance->versionRequirement()));
                break;
            case RequiresSetting::class:
                assert($attributeInstance instanceof RequiresSetting);
                $result[] = Metadata::requiresSettingOnClass($attributeInstance->setting(), $attributeInstance->value());
                break;
            case RunClassInSeparateProcess::class:
                $result[] = Metadata::runClassInSeparateProcess();
                break;
            case RunTestsInSeparateProcesses::class:
                $result[] = Metadata::runTestsInSeparateProcesses();
                break;
            case Small::class:
                $result[] = Metadata::groupOnClass('small');
                break;
            case TestDox::class:
                assert($attributeInstance instanceof TestDox);
                $result[] = Metadata::testDoxOnClass($attributeInstance->text());
                break;
            case Ticket::class:
                assert($attributeInstance instanceof Ticket);
                $result[] = Metadata::groupOnClass($attributeInstance->text());
                break;
            case UsesClass::class:
                assert($attributeInstance instanceof UsesClass);
                $result[] = Metadata::usesClass($attributeInstance->className());
                break;
            case UsesFunction::class:
                assert($attributeInstance instanceof UsesFunction);
                $result[] = Metadata::usesFunction($attributeInstance->functionName());
                break;
        }
    }
    return MetadataCollection::fromArray($result);
}