Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\DomainExceptionRule

Complexity

Total Complexity

18

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	processNode()	0	27	7
B	validateDomainExceptionClass()	0	40	9
A	getNodeType()	0	3	1
A	__construct()	0	3	1

<?php declare(strict_types=1);

namespace Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules;

use PhpParser\Node;
use PhpParser\Node\Stmt\Throw_;
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\Reflection\ReflectionProvider;

The type PHPStan\Reflection\ReflectionProvider 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\Rules\RuleError;

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

use PHPStan\Rules\RuleErrorBuilder;

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

use Shopware\Core\Framework\HttpException;
use Shopware\Core\Framework\Log\Package;
use Shopware\Core\Framework\Plugin\Exception\DecorationPatternException;
use Shopware\Core\Framework\Validation\Exception\ConstraintViolationException;

/**
 * @internal
 *
 * @implements Rule<Throw_>
 */
#[Package('core')]
class DomainExceptionRule implements Rule
{
    use InTestClassTrait;

    private const VALID_EXCEPTION_CLASSES = [
        DecorationPatternException::class,
        ConstraintViolationException::class,
    ];

    private const VALID_SUB_DOMAINS = [
        'Cart',
        'Payment',
        'Order',
    ];

    public function __construct(
        private ReflectionProvider $reflectionProvider
    ) {
    }

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

    public function processNode(Node $node, Scope $scope): array
    {
        if ($this->isInTestClass($scope) || !$scope->isInClass()) {
            return [];
        }

        if (!$node instanceof Throw_) {
            return [];
        }

        if ($node->expr instanceof Node\Expr\StaticCall) {
            return $this->validateDomainExceptionClass($node->expr, $scope);
        }

        if (!$node->expr instanceof Node\Expr\New_) {
            return [];
        }

        \assert($node->expr->class instanceof Node\Name);
        $exceptionClass = $node->expr->class->toString();

        if (\in_array($exceptionClass, self::VALID_EXCEPTION_CLASSES, true)) {
            return [];
        }

        return [
            RuleErrorBuilder::message('Throwing new exceptions within classes are not allowed. Please use domain exception pattern. See https://github.com/shopware/platform/blob/v6.4.20.0/adr/2022-02-24-domain-exceptions.md')->build(),
        ];
    }

    /**
     * @return list<RuleError>

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

     */
    private function validateDomainExceptionClass(Node\Expr\StaticCall $node, Scope $scope): array
    {
        \assert($node->class instanceof Node\Name);
        $exceptionClass = $node->class->toString();

        if (!\str_starts_with($exceptionClass, 'Shopware\\Core\\')) {
            return [];

The expression return array() returns the type array which is incompatible with the documented return type Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\list.

        }

        $exception = $this->reflectionProvider->getClass($exceptionClass);
        if (!$exception->isSubclassOf(HttpException::class)) {
            return [

The expression return array(PHPStan\Rules\RuleErrorBuilder::message(sprintf('Domain exception class %s has to extend the \Shopware\Core\Framework\HttpException class', $exceptionClass))->build()) returns the type array which is incompatible with the documented return type Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\list.

                RuleErrorBuilder::message(\sprintf('Domain exception class %s has to extend the \Shopware\Core\Framework\HttpException class', $exceptionClass))->build(),
            ];
        }

        $reflection = $scope->getClassReflection();
        \assert($reflection !== null);
        if (!\str_starts_with($reflection->getName(), 'Shopware\\Core\\')) {
            return [];

The expression return array() returns the type array which is incompatible with the documented return type Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\list.

        }
        $parts = \explode('\\', $reflection->getName());

        $expected = \sprintf('Shopware\\Core\\%s\\%s\\%sException', $parts[2], $parts[3], $parts[3]);

        if ($exceptionClass !== $expected && !$exception->isSubclassOf($expected)) {
            // Is it in a subdomain?
            if (isset($parts[5]) && \in_array($parts[4], self::VALID_SUB_DOMAINS, true)) {
                $expectedSub = \sprintf('\\%s\\%sException', $parts[4], $parts[4]);
                if (\str_starts_with(strrev($exceptionClass), strrev($expectedSub))) {
                    return [];

The expression return array() returns the type array which is incompatible with the documented return type Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\list.

                }
            }

            return [

The expression return array(PHPStan\Rules\RuleErrorBuilder::message(sprintf('Expected domain exception class %s, got %s', $expected, $exceptionClass))->build()) returns the type array which is incompatible with the documented return type Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\list.

                RuleErrorBuilder::message(\sprintf('Expected domain exception class %s, got %s', $expected, $exceptionClass))->build(),
            ];
        }

        return [];

The expression return array() returns the type array which is incompatible with the documented return type Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\list.

    }
}