League\Tactician\PHPStan\TacticianRuleSet

Complexity

Total Complexity

22

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Test Coverage

Coverage

97.33%

Importance

Changes	6
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
B	inspectCommandType()	0	58	6
A	getInspectableCommandTypes()	0	25	5
B	processNode()	0	30	7
A	getNodeType()	0	3	1
A	getHandlerClassAndMethodNames()	0	9	2

<?php
declare(strict_types=1);

namespace League\Tactician\PHPStan;

use League\Tactician\Handler\Mapping\CommandToHandlerMapping;
use League\Tactician\Handler\Mapping\MethodDoesNotExist;
use PhpParser\Node;
use PhpParser\Node\Expr\MethodCall;
use PHPStan\Analyser\Scope;

The type PHPStan\Analyser\Scope was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Broker\Broker;

The type PHPStan\Broker\Broker was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Broker\ClassNotFoundException;

The type PHPStan\Broker\ClassNotFoundException was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Reflection\MissingMethodFromReflectionException;

The type PHPStan\Reflection\MissingMethodFromReflectionException was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Reflection\ParametersAcceptorSelector;

The type PHPStan\Reflection\ParametersAcceptorSelector was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Rules\Rule;

The type PHPStan\Rules\Rule was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Type\ObjectType;

The type PHPStan\Type\ObjectType was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Type\Type;

The type PHPStan\Type\Type was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Type\TypeWithClassName;

The type PHPStan\Type\TypeWithClassName was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Type\UnionType;

The type PHPStan\Type\UnionType was not found. Maybe you did not declare it correctly or list all dependencies?

use function array_filter;
use function array_merge;

/** @implements \PHPStan\Rules\Rule<\PhpParser\Node\Expr\MethodCall> */
final class TacticianRuleSet implements Rule
{
    /**
     * @var CommandToHandlerMapping
     */
    private $mapping;
    /**
     * @var Broker
     */
    private $broker;
    /**
     * @var string
     */
    private $commandBusClass;
    /**
     * @var string
     */
    private $commandBusMethod;

    public function __construct(
        CommandToHandlerMapping $mapping,
        Broker $broker,
        string $commandBusClass,
        string $commandBusMethod
    ) {
        $this->mapping = $mapping;
        $this->broker = $broker;
        $this->commandBusClass = $commandBusClass;
        $this->commandBusMethod = $commandBusMethod;
    }

    public function getNodeType(): string
    {
        return MethodCall::class;
    }

    public function processNode(Node $methodCall, Scope $scope): array
    {
        if (! $methodCall instanceof MethodCall
            || ! $methodCall->name instanceof Node\Identifier
            || $methodCall->name->name !== $this->commandBusMethod) {
            return [];
        }

        $type = $scope->getType($methodCall->var);

        if (! (new ObjectType($this->commandBusClass))->isSuperTypeOf($type)->yes()) {
            return [];
        }

        // Wrong number of arguments passed to handle? Delegate to other PHPStan rules
        if (count($methodCall->args) !== 1) {
            return []; //
        }

        $commandType = $scope->getType($methodCall->args[0]->value);

The property value does not seem to exist on PhpParser\Node\VariadicPlaceholder.

        $errors = [];
        foreach ($this->getInspectableCommandTypes($commandType) as $commandType) {
            $errors = array_merge(
                $errors,
                $this->inspectCommandType($methodCall, $scope, $commandType)
            );
        }

        return $errors;
    }

    /**
     * @return array<string>
     */
    private function inspectCommandType(
        MethodCall $methodCallOnBus,
        Scope $scope,
        TypeWithClassName $commandType
    ): array {
        [$handlerClassName, $handlerMethodName] = $this->getHandlerClassAndMethodNames($commandType);

        try {
            $handlerClass = $this->broker->getClass($handlerClassName);
        } catch (ClassNotFoundException $e) {
            return [
                "Tactician tried to route the command {$commandType->getClassName()} but could not find the matching " .
                "handler {$handlerClassName}.",
            ];
        }

        try {
            $handlerMethod = $handlerClass->getMethod($handlerMethodName, $scope);
        } catch (MissingMethodFromReflectionException $e) {
            return [
                "Tactician tried to route the command {$commandType->getClassName()} to " .
                "{$handlerClass->getName()}::{$handlerMethodName} but while the class could be loaded, the method " .
                "'{$handlerMethodName}' could not be found on the class.",
            ];
        }

        /** @var \PHPStan\Reflection\ParameterReflection[] $parameters */
        $parameters = ParametersAcceptorSelector::selectFromArgs(
            $scope,
            $methodCallOnBus->args,
            $handlerMethod->getVariants()
        )->getParameters();

        if (count($parameters) === 0) {
            return [
                "Tactician tried to route the command {$commandType->getClassName()} to " .
                "{$handlerClass->getName()}::{$handlerMethodName} but the method '{$handlerMethodName}' does not " .
                "accept any parameters.",
            ];
        }

        if (count($parameters) > 1) {
            return [
                "Tactician tried to route the command {$commandType->getClassName()} to " .
                "{$handlerClass->getName()}::{$handlerMethodName} but the method '{$handlerMethodName}' accepts " .
                "too many parameters.",
            ];
        }

        if ($parameters[0]->getType()->accepts($commandType, true)->no()) {
            return [
                "Tactician tried to route the command {$commandType->getClassName()} to " .
                "{$handlerClass->getName()}::{$handlerMethodName} but the method '{$handlerMethodName}' has a " .
                "typehint that does not allow this command.",
            ];
        }

        return [];
    }

    /** @return TypeWithClassName[] */
    private function getInspectableCommandTypes(Type $type): array
    {
        $types = [];
        if ($type instanceof TypeWithClassName) {
            $types = [$type];
        }

        if ($type instanceof UnionType) {
            $types = array_filter(
                $type->getTypes(),
                function (Type $type) {
                    return $type instanceof TypeWithClassName;
                }
            );
        }

        return array_filter(
            $types,
            function (TypeWithClassName $type) {
                if (! $this->broker->hasClass($type->getClassName())) {
                    return false;
                }

                $class = $this->broker->getClass($type->getClassName());
                return ! $class->isInterface() && ! $class->isAbstract();
            }
        );
    }

    /**
     * @return string[]
     */
    private function getHandlerClassAndMethodNames(TypeWithClassName $commandType): array
    {
        try {
            $handler = $this->mapping->findHandlerForCommand($commandType->getClassName());

            return [$handler->getClassName(), $handler->getMethodName()];
        } catch (MethodDoesNotExist $e) {
            // Suppress this exception because PHPStan will find this on its own in a much nicer way
            return [$e->getClassName(), $e->getMethodName()];
        }
    }
}