Spiral\Tokenizer\Attribute\TargetAttribute

Complexity

Total Complexity

22

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
D	filter()	0	70	19
A	getScope()	0	3	1
A	__construct()	0	5	1
A	getCacheKey()	0	3	1

<?php

declare(strict_types=1);

namespace Spiral\Tokenizer\Attribute;

use Spiral\Attributes\AttributeReader;
use Spiral\Attributes\Factory;
use Spiral\Attributes\NamedArgumentConstructor;
use Spiral\Tokenizer\TokenizationListenerInterface;

/**
 * When applied to a listener, this attribute will instruct the tokenizer to listen for classes that use attributes of
 * the given class.
 * @see TokenizationListenerInterface
 */
#[\Attribute(\Attribute::TARGET_CLASS | \Attribute::IS_REPEATABLE), NamedArgumentConstructor]
final class TargetAttribute implements ListenerDefinitionInterface
{
    /**
     * @param class-string $class

The doc comment class-string at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string.

     * @param non-empty-string|null $scope
     */
    public function __construct(
        public readonly string $class,
        public readonly ?string $scope = null,
        public readonly bool $useAnnotations = false,
    ) {
    }

    public function filter(array $classes): \Generator
    {
        $target = new \ReflectionClass($this->class);
        $attribute = $target->getAttributes(\Attribute::class)[0] ?? null;

        // If annotations are used, we need to use the annotation reader also
        // It will slow down the process a bit, but it will allow us to use annotations
        $reader = $this->useAnnotations
            ? (new Factory())->create()
            : new AttributeReader();

        if ($attribute === null) {
            return;
        }

        $attribute = $attribute->newInstance();

        foreach ($classes as $class) {
            // If attribute is defined on class level and class has target attribute
            // then we can add it to the list of classes
            if (($attribute->flags & \Attribute::TARGET_CLASS)
                && $reader->firstClassMetadata($class, $target->getName())
            ) {
                yield $class->getName();
                continue;
            }

            // If attribute is defined on method level and class methods has target attribute
            // then we can add it to the list of classes
            if ($attribute->flags & \Attribute::TARGET_METHOD) {
                foreach ($class->getMethods() as $method) {
                    if ($reader->firstFunctionMetadata($method, $target->getName())) {
                        yield $class->getName();
                        continue 2;
                    }
                }
            }

            // If attribute is defined on property level and class properties has target attribute
            // then we can add it to the list of classes
            if ($attribute->flags & \Attribute::TARGET_PROPERTY) {
                foreach ($class->getProperties() as $property) {
                    if ($reader->firstPropertyMetadata($property, $target->getName())) {
                        yield $class->getName();
                        continue 2;
                    }
                }
            }


            // If attribute is defined on constant level and class constants has target attribute
            // then we can add it to the list of classes
            if ($attribute->flags & \Attribute::TARGET_CLASS_CONSTANT) {
                foreach ($class->getReflectionConstants() as $constant) {
                    if ($reader->firstConstantMetadata($constant, $target->getName())) {
                        yield $class->getName();
                        continue 2;
                    }
                }
            }


            // If attribute is defined on method parameters level and class method parameter has target attribute
            // then we can add it to the list of classes
            if ($attribute->flags & \Attribute::TARGET_PARAMETER) {
                foreach ($class->getMethods() as $method) {
                    foreach ($method->getParameters() as $parameter) {
                        if ($reader->firstParameterMetadata($parameter, $target->getName())) {
                            yield $class->getName();
                            continue 3;
                        }
                    }
                }
            }
        }
    }

    public function getScope(): ?string
    {
        return $this->scope;
    }

    public function getCacheKey(): string
    {
        return \md5($this->class . $this->scope);
    }
}