Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\NoDALAutoload

Complexity

Total Complexity

16

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	getNodeType()	0	3	1
A	__construct()	0	3	1
C	processNode()	0	74	14

<?php declare(strict_types=1);

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

use PhpParser\Node;
use PhpParser\Node\Expr\New_;
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 PHPStan\Type\Constant\ConstantStringType;

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

use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToOneAssociationField;
use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToOneAssociationField;
use Shopware\Core\Framework\Log\Package;

/**
 * @implements Rule<New_>
 *
 * @internal
 */
#[Package('core')]
class NoDALAutoload implements Rule
{
    private const ASSOCIATIONS_WITH_AUTOLOAD = [
        OneToOneAssociationField::class,
        ManyToOneAssociationField::class,
    ];

    private ReflectionProvider $reflectionProvider;

    public function __construct(ReflectionProvider $reflectionProvider)
    {
        $this->reflectionProvider = $reflectionProvider;
    }

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

    /**
     * @param New_ $node
     *
     * @return array<array-key, RuleError|string>

The doc comment array<array-key, RuleError|string> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, RuleError|string>.

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

        $definitionClassReflection = $scope->getClassReflection()->getNativeReflection();
        $className = $definitionClassReflection->getName();
        if (str_contains($className, 'Test')) {
            //if in a test namespace, don't care
            return [];
        }

        if (!$node->class instanceof Node\Name) {

Accessing class on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

            return [];
        }

        if (!\in_array($node->class->toString(), self::ASSOCIATIONS_WITH_AUTOLOAD, true)) {
            return [];
        }

        $classReflection = $this->reflectionProvider
            ->getClass($node->class->toString())
            ->getNativeReflection();

        $construct = $classReflection->getMethod('__construct');

        $autoloadParamPosition = null;
        $propertyNameParamPosition = null;
        foreach ($construct->getParameters() as $param) {
            if ($param->name === 'autoload') {
                $autoloadParamPosition = $param->getPosition();
            }

            if ($param->name === 'propertyName') {
                $propertyNameParamPosition = $param->getPosition();
            }
        }

        if ($autoloadParamPosition === null || $propertyNameParamPosition === null) {
            //cannot find autoload or propertyName parameter
            return [];
        }

        if (!isset($node->getArgs()[$autoloadParamPosition])) {

The method getArgs() does not exist on PhpParser\Node. It seems like you code against a sub-type of PhpParser\Node such as PhpParser\Node\Expr\CallLike.

            //autoload parameter not passed
            return [];
        }

        $autoloadValueExpr = $node->getArgs()[$autoloadParamPosition]->value;
        $propertyNameValueExpr = $node->getArgs()[$propertyNameParamPosition]->value;

        if ($scope->getType($autoloadValueExpr)->isTrue()->yes()) {
            $constant = $definitionClassReflection->getConstant('ENTITY_NAME');

            if ($constant === false) {
                return [];
            }

            $propType = $scope->getType($propertyNameValueExpr);
            if (!$propType instanceof ConstantStringType) {
                return [];
            }

            return [
                RuleErrorBuilder::message(sprintf(
                    '%s.%s association has a configured autoload===true, this is forbidden for platform integrations',
                    $constant,
                    $propType->getValue()
                ))->build(),
            ];
        }

        return [];
    }
}