Spiral\Interceptors\Context\Target

Complexity

Total Complexity

11

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	fromPathArray()	0	3	1
A	fromPathString()	0	4	1
A	__toString()	0	5	1
A	fromReflection()	0	3	1
A	withReflection()	0	5	1
A	withPath()	0	5	1
A	getReflection()	0	3	1
A	getPath()	0	10	1
A	fromPair()	0	5	2

<?php

declare(strict_types=1);

namespace Spiral\Interceptors\Context;

final class Target implements TargetInterface
{
    /**
     * @param list<string> $path

The type Spiral\Interceptors\Context\list was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param \ReflectionFunctionAbstract|null $reflection
     */
    private function __construct(
        private ?array $path = null,
        private ?\ReflectionFunctionAbstract $reflection = null,
        private readonly string $delimiter = '.',
    ) {
    }

    public function __toString(): string
    {
        return match (true) {
            $this->path !== null => \implode($this->delimiter, $this->path),

It seems like $this->path can also be of type null; however, parameter $pieces of implode() does only seem to accept array, maybe add an additional type check?

            $this->reflection !== null => $this->reflection->getName(),

The method getName() does not exist on null.

        };
    }

    public static function fromReflection(\ReflectionFunctionAbstract $reflection): self
    {
        return new self(reflection: $reflection);
    }

    public static function fromPathString(string $path, string $delimiter = '.'): self
    {
        /** @psalm-suppress ArgumentTypeCoercion */
        return new self(path: \explode($delimiter, $path), delimiter: $delimiter);
    }

    /**
     * @param list<string> $path
     */
    public static function fromPathArray(array $path, string $delimiter = '.'): self
    {
        return new self(path: $path, delimiter: $delimiter);
    }

    public static function fromPair(string $controller, string $action): self
    {
        return \method_exists($controller, $action)
            ? self::fromReflection(new \ReflectionMethod($controller, $action))
            : self::fromPathArray([$controller, $action]);
    }

    public function getPath(): array
    {
        return match (true) {
            $this->path !== null => $this->path,
            $this->reflection instanceof \ReflectionMethod => [
                $this->reflection->getDeclaringClass()->getName(),

The method getDeclaringClass() does not exist on ReflectionFunctionAbstract. It seems like you code against a sub-type of ReflectionFunctionAbstract such as ReflectionMethod.

                $this->reflection->getName(),
            ],
            $this->reflection instanceof \ReflectionFunction => [$this->reflection->getName()],
            default => [],
        };
    }

    public function withPath(array $path): static
    {
        $clone = clone $this;
        $clone->path = $path;

It seems like $path of type array is incompatible with the declared type Spiral\Interceptors\Context\list of property $path.

        return $clone;
    }

    public function getReflection(): ?\ReflectionFunctionAbstract
    {
        return $this->reflection;
    }

    public function withReflection(?\ReflectionFunctionAbstract $reflection): static
    {
        $clone = clone $this;
        $clone->reflection = $reflection;
        return $clone;
    }
}