Shopware\Psh\Config\Config

Complexity

Total Complexity

22

Size/Duplication

Total Lines	204
Duplicated Lines	7.84 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	getTemplates()	0	7	1
A	getDynamicVariables()	0	7	1
A	getConstants()	0	8	1
A	getAllScriptPaths()	9	16	4
A	getDotenvPaths()	0	18	2
A	getHeader()	0	4	1
A	getEnvironments()	0	4	1
A	getDefaultEnvironment()	0	4	1
A	getParams()	0	4	1
A	createResult()	0	12	3
A	getEnvironment()	0	8	2
A	resolveEnvironmentDotEnvPaths()	7	14	3

<?php declare(strict_types=1);

namespace Shopware\Psh\Config;

/**
 * Represents the global configuration consisting of multiple environments
 */
class Config
{
    /**
     * @var string
     */
    private $header;

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

    /**
     * @var ConfigEnvironment[]
     */
    private $environments;

    /**
     * @var array
     */
    private $params;

    /**
     * @param string|null $header
     * @param string $defaultEnvironment
     * @param ConfigEnvironment[] $environments
     * @param array $params
     */
    public function __construct(
        string $header = null,
        string $defaultEnvironment,
        array $environments,
        array $params
    ) {
        $this->header = $header;
        $this->defaultEnvironment = $defaultEnvironment;
        $this->environments = $environments;
        $this->params = $params;
    }

    /**
     * @return ScriptPath[]
     */
    public function getAllScriptPaths(): array
    {
        $paths = [];

        foreach ($this->environments as $name => $environmentConfig) {

This code seems to be duplicated across your project.

            foreach ($environmentConfig->getAllScriptPaths() as $path) {
                if ($name !== $this->defaultEnvironment) {

The strict comparison !== seems to always evaluate to true as the types of $name (integer) and $this->defaultEnvironment (string) can never be identical. Maybe you want to use a loose comparison != instead?

                    $paths[] = new ScriptPath($path, $name);
                } else {
                    $paths[] = new ScriptPath($path);
                }
            }
        }

        return $paths;
    }

    /**
     * @param string|null $environment
     * @return array
     */
    public function getTemplates(string $environment = null): array
    {
        return $this->createResult(
            [$this->getEnvironment(), 'getTemplates'],
            [$this->getEnvironment($environment), 'getTemplates']
        );
    }

    /**
     * @param string|null $environment
     * @return array
     */
    public function getDynamicVariables(string $environment = null): array
    {
        return $this->createResult(
            [$this->getEnvironment(), 'getDynamicVariables'],
            [$this->getEnvironment($environment), 'getDynamicVariables']
        );
    }

    /**
     * @param string|null $environment
     * @return array
     */
    public function getConstants(string $environment = null): array
    {
        return $this->createResult(
            [$this->getEnvironment(), 'getConstants'],
            [$this->getEnvironment($environment), 'getConstants'],
            [$this, 'getParams']
        );
    }

    /**
     * @param string|null $environmentString
     *
     * @return ScriptPath[]
     */
    public function getDotenvPaths(string $environmentString = null): array
    {
        $environmentString = $environmentString ?? ConfigBuilder::DEFAULT_ENV;

        $paths = $this->resolveEnvironmentDotEnvPaths(
            $this->getEnvironment($this->defaultEnvironment),
            $this->defaultEnvironment
        );

        if ($environmentString !== $this->defaultEnvironment) {
            $paths = $this->resolveEnvironmentDotEnvPaths(
                $this->getEnvironment($environmentString),
                $environmentString
            );
        }

        return $paths;
    }

    /**
     * @return string
     */
    public function getHeader()
    {
        return $this->header;
    }

    /**
     * @return ConfigEnvironment[]
     */
    public function getEnvironments(): array
    {
        return $this->environments;
    }

    /**
     * @return string
     */
    public function getDefaultEnvironment(): string
    {
        return $this->defaultEnvironment;
    }

    /**
     * @return array
     */
    public function getParams() : array
    {
        return $this->params;
    }

    /**
     * @param callable[] ...$valueProviders
     * @return array
     */
    private function createResult(callable ...$valueProviders): array
    {
        $mergedKeyValues = [];

        foreach ($valueProviders as $valueProvider) {
            foreach ($valueProvider() as $key => $value) {
                $mergedKeyValues[$key] = $value;
            }
        }

        return $mergedKeyValues;
    }

    /**
     * @param string|null $name
     * @return ConfigEnvironment
     */
    private function getEnvironment(string $name = null): ConfigEnvironment
    {
        if (!$name) {

The expression $name of type null|string is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

            return $this->environments[$this->defaultEnvironment];
        }

        return $this->environments[$name];
    }

    /**
     * @param ConfigEnvironment $environmentConfig
     * @param string|null $name
     *
     * @return array
     */
    private function resolveEnvironmentDotEnvPaths(ConfigEnvironment $environmentConfig, string $name = null): array
    {
        $paths = [];

        foreach ($environmentConfig->getDotenvPaths() as $path) {

This code seems to be duplicated across your project.

            if ($name !== $this->defaultEnvironment) {
                $paths[] = new ScriptPath($path, $name);
            } else {
                $paths[] = new ScriptPath($path);
            }
        }

        return $paths;
}
}