function AttributeParser::forMethod

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

Overrides Parser::forMethod

1 call to AttributeParser::forMethod()

AttributeParser::forClassAndMethod in vendor/phpunit/phpunit/src/Metadata/Parser/AttributeParser.php

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

File

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

Class

AttributeParser

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

Namespace

PHPUnit\Metadata\Parser

Code

public function forMethod(string $className, string $methodName) : MetadataCollection {
    assert(class_exists($className));
    assert(method_exists($className, $methodName));
    $result = [];
    foreach ((new ReflectionMethod($className, $methodName))->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 After::class:
                $result[] = Metadata::after();
                break;
            case AfterClass::class:
                $result[] = Metadata::afterClass();
                break;
            case BackupGlobals::class:
                assert($attributeInstance instanceof BackupGlobals);
                $result[] = Metadata::backupGlobalsOnMethod($attributeInstance->enabled());
                break;
            case BackupStaticProperties::class:
                assert($attributeInstance instanceof BackupStaticProperties);
                $result[] = Metadata::backupStaticPropertiesOnMethod($attributeInstance->enabled());
                break;
            case Before::class:
                $result[] = Metadata::before();
                break;
            case BeforeClass::class:
                $result[] = Metadata::beforeClass();
                break;
            case CoversNothing::class:
                $result[] = Metadata::coversNothingOnMethod();
                break;
            case DataProvider::class:
                assert($attributeInstance instanceof DataProvider);
                $result[] = Metadata::dataProvider($className, $attributeInstance->methodName());
                break;
            case DataProviderExternal::class:
                assert($attributeInstance instanceof DataProviderExternal);
                $result[] = Metadata::dataProvider($attributeInstance->className(), $attributeInstance->methodName());
                break;
            case Depends::class:
                assert($attributeInstance instanceof Depends);
                $result[] = Metadata::dependsOnMethod($className, $attributeInstance->methodName(), false, false);
                break;
            case DependsUsingDeepClone::class:
                assert($attributeInstance instanceof DependsUsingDeepClone);
                $result[] = Metadata::dependsOnMethod($className, $attributeInstance->methodName(), true, false);
                break;
            case DependsUsingShallowClone::class:
                assert($attributeInstance instanceof DependsUsingShallowClone);
                $result[] = Metadata::dependsOnMethod($className, $attributeInstance->methodName(), false, true);
                break;
            case DependsExternal::class:
                assert($attributeInstance instanceof DependsExternal);
                $result[] = Metadata::dependsOnMethod($attributeInstance->className(), $attributeInstance->methodName(), false, false);
                break;
            case DependsExternalUsingDeepClone::class:
                assert($attributeInstance instanceof DependsExternalUsingDeepClone);
                $result[] = Metadata::dependsOnMethod($attributeInstance->className(), $attributeInstance->methodName(), true, false);
                break;
            case DependsExternalUsingShallowClone::class:
                assert($attributeInstance instanceof DependsExternalUsingShallowClone);
                $result[] = Metadata::dependsOnMethod($attributeInstance->className(), $attributeInstance->methodName(), false, true);
                break;
            case DependsOnClass::class:
                assert($attributeInstance instanceof DependsOnClass);
                $result[] = Metadata::dependsOnClass($attributeInstance->className(), false, false);
                break;
            case DependsOnClassUsingDeepClone::class:
                assert($attributeInstance instanceof DependsOnClassUsingDeepClone);
                $result[] = Metadata::dependsOnClass($attributeInstance->className(), true, false);
                break;
            case DependsOnClassUsingShallowClone::class:
                assert($attributeInstance instanceof DependsOnClassUsingShallowClone);
                $result[] = Metadata::dependsOnClass($attributeInstance->className(), false, true);
                break;
            case DoesNotPerformAssertions::class:
                assert($attributeInstance instanceof DoesNotPerformAssertions);
                $result[] = Metadata::doesNotPerformAssertionsOnMethod();
                break;
            case ExcludeGlobalVariableFromBackup::class:
                assert($attributeInstance instanceof ExcludeGlobalVariableFromBackup);
                $result[] = Metadata::excludeGlobalVariableFromBackupOnMethod($attributeInstance->globalVariableName());
                break;
            case ExcludeStaticPropertyFromBackup::class:
                assert($attributeInstance instanceof ExcludeStaticPropertyFromBackup);
                $result[] = Metadata::excludeStaticPropertyFromBackupOnMethod($attributeInstance->className(), $attributeInstance->propertyName());
                break;
            case Group::class:
                assert($attributeInstance instanceof Group);
                $result[] = Metadata::groupOnMethod($attributeInstance->name());
                break;
            case IgnoreDeprecations::class:
                assert($attributeInstance instanceof IgnoreDeprecations);
                $result[] = Metadata::ignoreDeprecationsOnMethod();
                break;
            case PostCondition::class:
                $result[] = Metadata::postCondition();
                break;
            case PreCondition::class:
                $result[] = Metadata::preCondition();
                break;
            case PreserveGlobalState::class:
                assert($attributeInstance instanceof PreserveGlobalState);
                $result[] = Metadata::preserveGlobalStateOnMethod($attributeInstance->enabled());
                break;
            case RequiresMethod::class:
                assert($attributeInstance instanceof RequiresMethod);
                $result[] = Metadata::requiresMethodOnMethod($attributeInstance->className(), $attributeInstance->methodName());
                break;
            case RequiresFunction::class:
                assert($attributeInstance instanceof RequiresFunction);
                $result[] = Metadata::requiresFunctionOnMethod($attributeInstance->functionName());
                break;
            case RequiresOperatingSystem::class:
                assert($attributeInstance instanceof RequiresOperatingSystem);
                $result[] = Metadata::requiresOperatingSystemOnMethod($attributeInstance->regularExpression());
                break;
            case RequiresOperatingSystemFamily::class:
                assert($attributeInstance instanceof RequiresOperatingSystemFamily);
                $result[] = Metadata::requiresOperatingSystemFamilyOnMethod($attributeInstance->operatingSystemFamily());
                break;
            case RequiresPhp::class:
                assert($attributeInstance instanceof RequiresPhp);
                $result[] = Metadata::requiresPhpOnMethod(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::requiresPhpExtensionOnMethod($attributeInstance->extension(), $versionConstraint);
                break;
            case RequiresPhpunit::class:
                assert($attributeInstance instanceof RequiresPhpunit);
                $result[] = Metadata::requiresPhpunitOnMethod(ConstraintRequirement::from($attributeInstance->versionRequirement()));
                break;
            case RequiresSetting::class:
                assert($attributeInstance instanceof RequiresSetting);
                $result[] = Metadata::requiresSettingOnMethod($attributeInstance->setting(), $attributeInstance->value());
                break;
            case RunInSeparateProcess::class:
                $result[] = Metadata::runInSeparateProcess();
                break;
            case Test::class:
                $result[] = Metadata::test();
                break;
            case TestDox::class:
                assert($attributeInstance instanceof TestDox);
                $result[] = Metadata::testDoxOnMethod($attributeInstance->text());
                break;
            case TestWith::class:
                assert($attributeInstance instanceof TestWith);
                $result[] = Metadata::testWith($attributeInstance->data());
                break;
            case TestWithJson::class:
                assert($attributeInstance instanceof TestWithJson);
                $result[] = Metadata::testWith(json_decode($attributeInstance->json(), true, 512, JSON_THROW_ON_ERROR));
                break;
            case Ticket::class:
                assert($attributeInstance instanceof Ticket);
                $result[] = Metadata::groupOnMethod($attributeInstance->text());
                break;
            case WithoutErrorHandler::class:
                assert($attributeInstance instanceof WithoutErrorHandler);
                $result[] = Metadata::withoutErrorHandler();
                break;
        }
    }
    return MetadataCollection::fromArray($result);
}