NamespaceProtector\Config\Config

Complexity

Total Complexity

15

Size/Duplication

Total Lines	164
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	getPathComposerJson()	0	3	1
A	getPlotter()	0	3	1
A	getMode()	0	3	1
A	__construct()	0	18	1
A	getVersion()	0	4	1
A	cloneWithWithOverride()	0	16	1
A	print()	0	20	2
A	getPublicEntries()	0	3	1
A	getStartPath()	0	3	1
A	getPrivateEntries()	0	3	1
A	validateLoadedConfig()	0	8	1
A	enabledCache()	0	3	1
A	populateOutputVarFromArray()	0	7	2

<?php declare(strict_types=1);

namespace NamespaceProtector\Config;

use NamespaceProtector\Common\PathInterface;
use Webmozart\Assert\Assert;

final class Config
{
    public const MODE_MAKE_VENDOR_PRIVATE = 'MODE_MAKE_VENDOR_PRIVATE';
    public const MODE_PUBLIC = 'PUBLIC';

    public const PLOTTER_TERMINAL = 'plotter-terminal';
    public const PLOTTER_PNG = 'plotter-png';

    /** @var PathInterface */
    private $pathStart;

    /** @var PathInterface  */
    private $pathComposerJson;

    /** @var array<string> */
    private $privateEntries;

    /** @var array<string> */
    private $publicEntries;

    /** @var string */
    private $mode;

    /** @var string */
    private $version;

    /** @var bool */
    private $enabledCache;

    /** @var string */
    private $plotter;

    /**
     * @param array<string> $privateEntries
     * @param array<string> $publicEntries
     */
    public function __construct(
        string $version,
        PathInterface $pathStart,
        PathInterface $pathComposerJson,
        array $privateEntries,
        array $publicEntries,
        string $mode = self::MODE_PUBLIC,
        bool $enabledCache = false,
        string $plotter = self::PLOTTER_TERMINAL
    ) {
        $this->version = $version;
        $this->pathStart = $pathStart;
        $this->pathComposerJson = $pathComposerJson;
        $this->privateEntries = $privateEntries;
        $this->publicEntries = $publicEntries;
        $this->mode = $mode;
        $this->enabledCache = $enabledCache;
        $this->plotter = $plotter;
    }

    public function getStartPath(): PathInterface
    {
        return $this->pathStart;
    }

    /**
     * @return array<string>
     */
    public function getPrivateEntries(): array
    {
        return $this->privateEntries;
    }

    /**
     * @return array<string>
     */
    public function getPublicEntries(): array
    {
        return $this->publicEntries;
    }

    public function getMode(): string
    {
        return $this->mode;
    }

    public function getPlotter(): string
    {
        return $this->plotter;
    }

    public function getPathComposerJson(): PathInterface
    {
        return $this->pathComposerJson;
    }

    public function print(): string
    {
        //todo: automatic dump config

        $prettyPrintPrivateEntries = $this->populateOutputVarFromArray($this->getPrivateEntries());
        $prettyPrintPublicEntries = $this->populateOutputVarFromArray($this->getPublicEntries());

        return
            '' . PHP_EOL .
            '|Dump config:' . PHP_EOL .
            '|> Version: ' . $this->getVersion() . PHP_EOL .
            '|> Cache: ' . ($this->enabledCache() === true ? 'TRUE' : 'FALSE') . PHP_EOL .
            '|> Plotter: ' . $this->getPlotter() . PHP_EOL .
            '|> Path start: ' . $this->pathStart->get() . PHP_EOL .
            '|> Composer Json path: ' . $this->pathComposerJson->get() . PHP_EOL .
            '|> Mode: ' . $this->getMode() . PHP_EOL .
            '|> Private entries: ' . $prettyPrintPrivateEntries . PHP_EOL .
            '|' . PHP_EOL .
            '|> Public entries: ' . $prettyPrintPublicEntries . PHP_EOL .
            '';
    }

    /**
     * @param array<string> $entries
     */
    private function populateOutputVarFromArray(array $entries): string
    {
        $prettyPrintNamespaceToValidate = "\n";
        foreach ($entries as $namespace) {
            $prettyPrintNamespaceToValidate .= '|       >' . $namespace . \PHP_EOL;
        }
        return $prettyPrintNamespaceToValidate;
    }

    /** @param array<string,string> $parameters */
    public function cloneWithWithOverride(self $config, array $parameters): self
    {
        $self = new self(
            $config->getVersion(),
            $config->getStartPath(),
            $config->getPathComposerJson(),
            $config->getPrivateEntries(),
            $config->getPublicEntries(),
            $config->getMode(),
            $config->enabledCache(),
            $parameters['plotter'] ?? $config->getPlotter(),
        );

        $self->validateLoadedConfig(); //todo: validation called multiple times

        return $self;
    }

    public function validateLoadedConfig(): void
    {
        Assert::inArray($this->getMode(), [self::MODE_PUBLIC, self::MODE_MAKE_VENDOR_PRIVATE], 'Mode not valid');
        Assert::eq('0.1.0', $this->getVersion(), 'Version not valid');
        Assert::directory($this->getStartPath()->get(), 'Start directory not valid');
        Assert::directory($this->getPathComposerJson()->get(), 'Composer json directory not valid');
        Assert::boolean($this->enabledCache(), 'Cache flag must be boolean');
        Assert::inArray($this->getPlotter(), [self::PLOTTER_TERMINAL, self::PLOTTER_PNG], 'Plotter not valid');
    }

    public function getVersion(): string
    {
        //todo: use https://github.com/nikolaposa/version
        return $this->version;
    }

    public function enabledCache(): bool
    {
        return $this->enabledCache;
    }
}