Murtukov\PHPCodeGenerator\DependencyAwareGenerator

Complexity

Total Complexity

20

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	useGroupsToArray()	0	9	2
A	getUsePaths()	0	18	5
A	removeUse()	0	6	1
A	resolveQualifier()	0	16	6
A	addUseGroup()	0	13	5
A	addUse()	0	5	1

<?php

declare(strict_types=1);

namespace Murtukov\PHPCodeGenerator;

abstract class DependencyAwareGenerator extends AbstractGenerator
{
    protected array $usePaths = [];
    protected array $useGroups = [];

    /**
     * List of all generator children, which maintain their own use dependencies.
     * The list should be defined in the constructor.
     *
     * @var mixed[]
     */
    protected array $dependencyAwareChildren = [];

    public function resolveQualifier(string $path, $alias = ''): string
    {
        if (empty($path) || false === Config::$shortenQualifiers || '\\' === $path[0]) {
            return $path;
        }

        if ($path[0] === Config::$suppressSymbol) {
            return substr($path, 1);
        }

        if ($qualifier = Utils::resolveQualifier($path)) {
            $this->usePaths[$path] = $alias;
            $path = $qualifier;
        }

        return $path;
    }

    public function addUse(string $fqcn, string ...$aliases): self
    {
        $this->usePaths[$fqcn] = implode(', ', $aliases);

        return $this;
    }

    public function addUseGroup(string $fqcn, string ...$classNames)
    {
        foreach ($classNames as $name) {
            if ($qualifier = Utils::resolveQualifier($name)) {
                $name = $qualifier;
            }

            if (empty($this->useGroups[$fqcn]) || !in_array($name, $this->useGroups[$fqcn])) {
                $this->useGroups[$fqcn][] = $name;
            }
        }

        return $this;
    }

    public function removeUse(string $fqcn): self
    {
        unset($this->usePaths[$fqcn]);
        unset($this->useGroups[$fqcn]);

        return $this;
    }

    public function useGroupsToArray()
    {
        $result = [];

        foreach ($this->useGroups as $path => $classNames) {
            $result[rtrim($path, '\\').'\{'.implode(', ', $classNames).'}'] = '';
        }

        return $result;
    }

    /**
     * Returns all use-qualifiers used in this object and all it's children.
     *
     * @return string[]
     */
    public function getUsePaths(): array
    {
        // Merge self use paths and use groups
        $mergedPaths = $this->usePaths + $this->useGroupsToArray();

        foreach ($this->dependencyAwareChildren as $child) {
            if (is_array($child)) {
                foreach ($child as $subchild) {
                    if ($subchild instanceof self) {
                        $mergedPaths = $mergedPaths + $subchild->getUsePaths();
                    }
                }
            } else {
                $mergedPaths = $mergedPaths + $child->getUsePaths();
            }
        }

        return $mergedPaths;
    }
}