Shopware\Psh\Config\Config

Complexity

Total Complexity

16

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

10 Methods

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

<?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;

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

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

        foreach ($this->environments as $name => $environmentConfig) {
            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']
        );
    }

    /**
     * @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;
    }

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

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

        foreach ($specificValues() 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];
    }
}