PhUml\Parser\Code\Builders\Members\FilteredConstantsBuilder

Complexity

Total Complexity

6

Size/Duplication

Total Lines	50
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	determineType()	0	10	4
A	build()	0	13	1

<?php declare(strict_types=1);
/**
 * PHP version 7.2
 *
 * 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\Const_;

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

use PhpParser\Node\Expr\ConstFetch;

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

use PhpParser\Node\Stmt\ClassConst;

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

use PhUml\Code\Attributes\Constant;
use PhUml\Code\Variables\TypeDeclaration;

/**
 * It builds an array of `Constants` for either a `ClassDefinition` or an `InterfaceDefinition`
 */
final class FilteredConstantsBuilder implements ConstantsBuilder
{
    /** @var string[] */
    private static $types = [
        'integer' => 'int',
        'double' => 'float',
        'string' => 'string',
    ];

    /** @var VisibilityBuilder */
    private $visibilityBuilder;

    /** @var VisibilityFilters */
    private $visibilityFilters;

    public function __construct(VisibilityBuilder $visibilityBuilder, VisibilityFilters $filters)
    {
        $this->visibilityBuilder = $visibilityBuilder;
        $this->visibilityFilters = $filters;
    }

    /**
     * @param Node[] $classAttributes
     * @return Constant[]
     */
    public function build(array $classAttributes): array
    {
        $constants = array_filter($classAttributes, static function ($attribute): bool {
            return $attribute instanceof ClassConst;
        });

        return array_map(function (ClassConst $constant): Constant {
            return new Constant(
                (string) $constant->consts[0]->name,
                TypeDeclaration::from($this->determineType($constant->consts[0])),
                $this->visibilityBuilder->build($constant)
            );
        }, $this->visibilityFilters->apply($constants));
    }

    private function determineType(Const_ $constant): ?string
    {
        if (property_exists($constant->value, 'value')) {
            return self::$types[\gettype($constant->value->value)];
        }
        if ($constant->value instanceof ConstFetch
            && \in_array($constant->value->name->parts[0], ['true', 'false'], true)) {
            return 'bool';
        }
        return null; // It's an expression
    }
}