PhUml\Parser\Code\Builders\Members\FilteredAttributesBuilder

Complexity

Total Complexity

3

Size/Duplication

Total Lines	48
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	build()	0	13	1
A	fromPromotedProperties()	0	16	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\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 FilteredAttributesBuilder implements AttributesBuilder
{
    public function __construct(
        private VisibilityBuilder $visibilityBuilder,
        private TypeBuilder $typeBuilder,
        private VisibilityFilters $visibilityFilters
    ) {
    }

    /**
     * @param Node[] $parsedAttributes
     * @return Attribute[]
     */
    public function build(array $parsedAttributes): array
    {
        $attributes = array_filter($parsedAttributes, static fn ($attribute): bool => $attribute instanceof Property);

        return array_map(function (Property $attribute): Attribute {
            $variable = new Variable(
                "\${$attribute->props[0]->name}",
                $this->typeBuilder->fromAttributeType($attribute->type, $attribute->getDocComment())
            );
            $visibility = $this->visibilityBuilder->build($attribute);

            return new Attribute($variable, $visibility, $attribute->isStatic());
        }, $this->visibilityFilters->apply($attributes));
    }

    /**
     * @param Node\Param[] $constructorParameters
     * @return Attribute[]
     */
    public function fromPromotedProperties(array $constructorParameters): array
    {
        $promotedProperties = array_filter($constructorParameters, fn (Node\Param $param) => $param->flags !== 0);

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

        return array_map(function (Node\Param $param): Attribute {
            /** @var Node\Expr\Variable $var */
            $var = $param->var;

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

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

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