Config::createMergedUpperCaseResult() - Code Metrics - Inspection of "Merge pull request #111 from shopwareLabs/next-min..." - shopwareLabs/psh - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0a4926...d192d3 )

by Jan Philipp

created 2021-06-11 09:31 UTC

Config::createMergedUpperCaseResult() A

↳ Parent: Config

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	12
rs	9.8666
c	0
b	0
f	0
cc	3
nc	3
nop	1

<?php declare(strict_types=1);

namespace Shopware\Psh\Config;

use Shopware\Psh\Application\RuntimeParameters;
use function array_map;
use function array_merge;
use function in_array;
use function mb_strtoupper;

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

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

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

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

    /**
     * @var RuntimeParameters
     */
    private $runtimeParameters;

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

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

        foreach ($this->environments as $name => $environmentConfig) {
            foreach ($environmentConfig->getAllScriptsPaths() as $path) {
                $paths[] = $path;
            }
        }

        return $paths;
    }

    public function getTemplates(?string $environment = null): array
    {
        $templates = $this->getEnvironment()->getTemplates();

        if ($environment === null) {
            return $templates;
        }

        foreach ($this->getEnvironment($environment)->getTemplates() as $template) {
            $templates[] = $template;
        }

        return $templates;
    }

    public function getDynamicVariables(?string $environment = null): array
    {
        return $this->resolver->resolveVariables($this->createMergedUpperCaseResult(
            [$this->getEnvironment(), 'getDynamicVariables'],
            [$this->getEnvironment($environment), 'getDynamicVariables']
        ));
    }

    public function getConstants(?string $environment = null): array
    {
        return $this->resolver->resolveConstants($this->createMergedUpperCaseResult(
            [$this->getEnvironment(), 'getConstants'],
            [$this->getEnvironment($environment), 'getConstants'],
            [$this, 'getParams']
        ));
    }

    public function getAllPlaceholders(?string $environment = null): array
    {
        return array_merge(
            $this->getConstants($environment),
            $this->getDotenvVariables($environment),
            $this->getDynamicVariables($environment)
        );
    }

    /**
     * @return ValueProvider[]
     */
    public function getDotenvVariables(?string $environment = null): array
    {
        $paths = $this->getDotenvPaths($environment);

        return $this->resolver->resolveDotenvVariables($paths);
    }

    /**
     * @return RequiredValue[]
     */
    public function getRequiredVariables(?string $environment = null): array
    {
        $requiredValues = $this->createMergedUpperCaseResult(
            [$this->getEnvironment(), 'getRequiredVariables'],
            [$this->getEnvironment($environment), 'getRequiredVariables']
        );

        $result = [];
        foreach ($requiredValues as $name => $description) {
            $result[$name] = new RequiredValue($name, $description);
        }

        return $result;
    }

    /**
     * @return DotenvFile[]
     */
    public function getDotenvPaths(?string $environment = null): array
    {
        $paths = $this->createMergedResult(
            [$this->getEnvironment(), 'getDotenvPaths'],
            [$this->getEnvironment($environment), 'getDotenvPaths']
        );

        return array_map(static function (string $path): DotenvFile {
            return new DotenvFile($path);
        }, $paths);
    }

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

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

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

    public function hasOption(string $name): bool
    {
        return in_array($name, $this->runtimeParameters->getAppParams(), true);
    }

    public function getImports(): array
    {
        return $this->getEnvironment()->getImports();
    }

    public function getScriptNames(): array
    {
        return $this->runtimeParameters->getCommands();
    }

    private function getParams(): array
    {
        return $this->runtimeParameters->getOverwrites();
    }

    private function createMergedResult(callable ...$valueProviders): array
    {
        $mergedKeyValues = [];

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

        return $mergedKeyValues;
    }

    private function createMergedUpperCaseResult(callable ...$valueProviders): array
    {
        $mergedKeyValues = [];

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

        return $mergedKeyValues;
    }

    private function getEnvironment(?string $name = null): ConfigEnvironment
    {
        if ($name === null) {
            return $this->environments[$this->defaultEnvironment];
        }

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


1			<?php declare(strict_types=1);
2
3			namespace Shopware\Psh\Config;
4
5			use Shopware\Psh\Application\RuntimeParameters;
6			use function array_map;
7			use function array_merge;
8			use function in_array;
9			use function mb_strtoupper;
10
11			/**
12			* Represents the global configuration consisting of multiple environments
13			*/
14			class Config
15			{
16			/**
17			* @var EnvironmentResolver
18			*/
19			private $resolver;
20
21			/**
22			* @var string
23			*/
24			private $header;
25
26			/**
27			* @var string
28			*/
29			private $defaultEnvironment;
30
31			/**
32			* @var ConfigEnvironment[]
33			*/
34			private $environments;
35
36			/**
37			* @var RuntimeParameters
38			*/
39			private $runtimeParameters;
40
41			/**
42			* @param ConfigEnvironment[] $environments
43			*/
44			public function __construct(
45			EnvironmentResolver $resolver,
46			string $defaultEnvironment,
47			array $environments,
48			RuntimeParameters $runtimeParameters,
49			?string $header = null
50			) {
51			$this->resolver = $resolver;
52			$this->defaultEnvironment = $defaultEnvironment;
53			$this->environments = $environments;
54			$this->runtimeParameters = $runtimeParameters;
55			$this->header = $header;
56			}
57
58			/**
59			* @return ScriptsPath[]
60			*/
61			public function getAllScriptsPaths(): array
62			{
63			$paths = [];
64
65			foreach ($this->environments as $name => $environmentConfig) {
66			foreach ($environmentConfig->getAllScriptsPaths() as $path) {
67			$paths[] = $path;
68			}
69			}
70
71			return $paths;
72			}
73
74			public function getTemplates(?string $environment = null): array
75			{
76			$templates = $this->getEnvironment()->getTemplates();
77
78			if ($environment === null) {
79			return $templates;
80			}
81
82			foreach ($this->getEnvironment($environment)->getTemplates() as $template) {
83			$templates[] = $template;
84			}
85
86			return $templates;
87			}
88
89			public function getDynamicVariables(?string $environment = null): array
90			{
91			return $this->resolver->resolveVariables($this->createMergedUpperCaseResult(
92			[$this->getEnvironment(), 'getDynamicVariables'],
93			[$this->getEnvironment($environment), 'getDynamicVariables']
94			));
95			}
96
97			public function getConstants(?string $environment = null): array
98			{
99			return $this->resolver->resolveConstants($this->createMergedUpperCaseResult(
100			[$this->getEnvironment(), 'getConstants'],
101			[$this->getEnvironment($environment), 'getConstants'],
102			[$this, 'getParams']
103			));
104			}
105
106			public function getAllPlaceholders(?string $environment = null): array
107			{
108			return array_merge(
109			$this->getConstants($environment),
110			$this->getDotenvVariables($environment),
111			$this->getDynamicVariables($environment)
112			);
113			}
114
115			/**
116			* @return ValueProvider[]
117			*/
118			public function getDotenvVariables(?string $environment = null): array
119			{
120			$paths = $this->getDotenvPaths($environment);
121
122			return $this->resolver->resolveDotenvVariables($paths);
123			}
124
125			/**
126			* @return RequiredValue[]
127			*/
128			public function getRequiredVariables(?string $environment = null): array
129			{
130			$requiredValues = $this->createMergedUpperCaseResult(
131			[$this->getEnvironment(), 'getRequiredVariables'],
132			[$this->getEnvironment($environment), 'getRequiredVariables']
133			);
134
135			$result = [];
136			foreach ($requiredValues as $name => $description) {
137			$result[$name] = new RequiredValue($name, $description);
138			}
139
140			return $result;
141			}
142
143			/**
144			* @return DotenvFile[]
145			*/
146			public function getDotenvPaths(?string $environment = null): array
147			{
148			$paths = $this->createMergedResult(
149			[$this->getEnvironment(), 'getDotenvPaths'],
150			[$this->getEnvironment($environment), 'getDotenvPaths']
151			);
152
153			return array_map(static function (string $path): DotenvFile {
154			return new DotenvFile($path);
155			}, $paths);
156			}
157
158			/**
159			* @return string
160			*/
161			public function getHeader(): ?string
162			{
163			return $this->header;
164			}
165
166			/**
167			* @return ConfigEnvironment[]
168			*/
169			public function getEnvironments(): array
170			{
171			return $this->environments;
172			}
173
174			public function getDefaultEnvironment(): string
175			{
176			return $this->defaultEnvironment;
177			}
178
179			public function hasOption(string $name): bool
180			{
181			return in_array($name, $this->runtimeParameters->getAppParams(), true);
182			}
183
184			public function getImports(): array
185			{
186			return $this->getEnvironment()->getImports();
187			}
188
189			public function getScriptNames(): array
190			{
191			return $this->runtimeParameters->getCommands();
192			}
193
194			private function getParams(): array
195			{
196			return $this->runtimeParameters->getOverwrites();
197			}
198
199			private function createMergedResult(callable ...$valueProviders): array
200			{
201			$mergedKeyValues = [];
202
203			foreach ($valueProviders as $valueProvider) {
204			foreach ($valueProvider() as $key => $value) {
205			$mergedKeyValues[$key] = $value;
206			}
207			}
208
209			return $mergedKeyValues;
210			}
211
212			private function createMergedUpperCaseResult(callable ...$valueProviders): array
213			{
214			$mergedKeyValues = [];
215
216			foreach ($valueProviders as $valueProvider) {
217			foreach ($valueProvider() as $key => $value) {
218			$mergedKeyValues[mb_strtoupper($key)] = $value;
219			}
220			}
221
222			return $mergedKeyValues;
223			}
224
225			private function getEnvironment(?string $name = null): ConfigEnvironment
226			{
227			if ($name === null) {
228			return $this->environments[$this->defaultEnvironment];
229			}
230
231			return $this->environments[$name];
232			}
233			}
234

shopwareLabs / psh

Push — master ( 0a4926...d192d3 )

Config::createMergedUpperCaseResult() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like