PhUml\Parser\Code\Builders\Members\ParsedAttributesBuilder

Complexity

Total Complexity

3

Size/Duplication

Total Lines	48
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	build()	0	11	1
A	__construct()	0	4	1
A	fromPromotedProperties()	0	19	1

<?php declare(strict_types=1);
/**
 * PHP version 8.0
 *
 * This source file is subject to the license that is bundled with this package in the file LICENSE.
 */

namespace PhUml\Parser\Code\Builders\Members;

use PhpParser\Node;

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

use PhpParser\Node\Stmt\Property;

The type PhpParser\Node\Stmt\Property was not found. Maybe you did not declare it correctly or list all dependencies?

use PhUml\Code\Attributes\Attribute;
use PhUml\Code\UseStatements;
use PhUml\Code\Variables\Variable;
use PhUml\Parser\Code\Builders\Filters\PrivateVisibilityFilter;
use PhUml\Parser\Code\Builders\Filters\ProtectedVisibilityFilter;

/**
 * It builds an array of `Attributes` for a `ClassDefinition` or a `TraitDefinition`
 *
 * It applies one or more `VisibilityFilter`s
 *
 * @see PrivateVisibilityFilter
 * @see ProtectedVisibilityFilter
 */
final class ParsedAttributesBuilder implements AttributesBuilder
{
    public function __construct(
        private VisibilityBuilder $visibilityBuilder,
        private TypeBuilder $typeBuilder,
    ) {
    }

    /**
     * @param Property[] $parsedAttributes
     * @return Attribute[]
     */
    public function build(array $parsedAttributes, UseStatements $useStatements): array
    {
        return array_map(function (Property $attribute) use ($useStatements): Attribute {
            $variable = new Variable(
                "\${$attribute->props[0]->name}",
                $this->typeBuilder->fromAttributeType($attribute->type, $attribute->getDocComment(), $useStatements)
            );
            $visibility = $this->visibilityBuilder->build($attribute);

            return new Attribute($variable, $visibility, $attribute->isStatic());
        }, $parsedAttributes);
    }

    /**
     * @param Node\Param[] $promotedProperties
     * @return Attribute[]
     */
    public function fromPromotedProperties(array $promotedProperties, UseStatements $useStatements): array
    {
        return array_map(function (Node\Param $param) use ($useStatements): Attribute {

The type PhpParser\Node\Param was not found. Maybe you did not declare it correctly or list all dependencies?

            /** @var Node\Expr\Variable $var */
            $var = $param->var;

            /** @var string $name */
            $name = $var->name;

            $type = $this->typeBuilder->fromMethodParameter(
                $param->type,
                $param->getDocComment(),
                $name,
                $useStatements
            );
            $visibility = $this->visibilityBuilder->fromFlags($param->flags);

            return new Attribute(new Variable("\$${name}", $type), $visibility);
        }, $promotedProperties);
    }
}