Shopware\Psh\ScriptRuntime\Execution\ProcessEnvironment

Complexity

Total Complexity

18

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	10

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	initializeConstants()	0	9	2
A	initializeVariables()	0	10	2
A	initializeDotenvVariables()	0	14	3
A	initializeTemplates()	0	9	2
A	getAllValues()	0	8	1
A	getTemplates()	0	4	1
A	createProcess()	0	4	1
A	loadDotenvVariables()	0	6	1
A	loadEnvVarsFromDotenvFile()	0	11	1
A	diffDotenvVarsWithCurrentApplicationEnv()	0	23	3

<?php declare(strict_types=1);

namespace Shopware\Psh\ScriptRuntime\Execution;

use Dotenv\Dotenv;
use Dotenv\Repository\Adapter\MultiReader;
use Dotenv\Repository\Adapter\PutenvAdapter;
use Dotenv\Repository\Adapter\ServerConstAdapter;
use Shopware\Psh\Config\DotenvFile;
use Shopware\Psh\Config\ScriptsPath;
use Symfony\Component\Process\Process;
use function array_keys;
use function array_merge;
use function pathinfo;

/**
 * Create representation of the current environment variables and constants
 */
class ProcessEnvironment
{
    /**
     * @var ValueProvider[]
     */
    private $constants;

    /**
     * @var ValueProvider[]
     */
    private $variables;

    /**
     * @var Template[]
     */
    private $templates;

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

    /**
     * @param ScriptsPath[] $dotenvPaths
     */
    public function __construct(array $constants, array $variables, array $templates, array $dotenvPaths)
    {
        $this->constants = $this->initializeConstants($constants);
        $this->variables = $this->initializeVariables($variables);
        $this->templates = $this->initializeTemplates($templates);
        $this->dotenvVariables = $this->initializeDotenvVariables($dotenvPaths);

$dotenvPaths is of type array<integer,object<Shopware\Psh\Config\ScriptsPath>>, but the function expects a array<integer,object<Shopware\Psh\Config\DotenvFile>>.

    }

    /**
     * @return ValueProvider[]
     */
    private function initializeConstants(array $constants): array
    {
        $resolvedValues = [];
        foreach ($constants as $name => $value) {
            $resolvedValues[$name] = new SimpleValueProvider((string) $value);
        }

        return $resolvedValues;
    }

    /**
     * @return ValueProvider[]
     */
    private function initializeVariables(array $variables): array
    {
        $resolvedVariables = [];
        foreach ($variables as $name => $shellCommand) {
            $process = $this->createProcess($shellCommand);
            $resolvedVariables[$name] = new ProcessValueProvider($process);
        }

        return $resolvedVariables;
    }

    /**
     * @param DotenvFile[] $dotenvPaths
     * @return ValueProvider[]
     */
    private function initializeDotenvVariables(array $dotenvPaths): array
    {
        $variables = [];

        foreach ($dotenvPaths as $dotenvPath) {
            $dotenvVariables = $this->loadDotenvVariables($dotenvPath);

            foreach ($dotenvVariables as $variableKey => $variableValue) {
                $variables[$variableKey] = new SimpleValueProvider($variableValue);
            }
        }

        return $variables;
    }

    /**
     * @return Template[]
     */
    private function initializeTemplates(array $templates): array
    {
        $resolvedVariables = [];
        foreach ($templates as $template) {
            $resolvedVariables[] = new Template($template['source'], $template['destination']);
        }

        return $resolvedVariables;
    }

    /**
     * @return ValueProvider[]
     */
    public function getAllValues(): array
    {
        return array_merge(
            $this->constants,
            $this->dotenvVariables,
            $this->variables
        );
    }

    /**
     * @return Template[]
     */
    public function getTemplates(): array
    {
        return $this->templates;
    }

    public function createProcess(string $shellCommand): Process
    {
        return new Process($shellCommand);

$shellCommand is of type string, but the function expects a array.

    }

    private function loadDotenvVariables(DotenvFile $dotenvPath): array
    {
        $fileData = $this->loadEnvVarsFromDotenvFile($dotenvPath);

        return $this->diffDotenvVarsWithCurrentApplicationEnv($fileData);
    }

    private function loadEnvVarsFromDotenvFile(DotenvFile $dotenvPath): array
    {
        $filePath = $dotenvPath->getPath();

        $dotenv = Dotenv::createArrayBacked(
            pathinfo($filePath, \PATHINFO_DIRNAME),
            pathinfo($filePath, \PATHINFO_BASENAME)
        );

        return $dotenv->load();
    }

    private function diffDotenvVarsWithCurrentApplicationEnv(array $fileData): array
    {
        $fileKeys = array_keys($fileData);
        $result = [];

        $reader = new MultiReader([
            PutenvAdapter::create()->get(),
            ServerConstAdapter::create()->get(),
        ]);

        foreach ($fileKeys as $key) {
            $option = $reader->read($key);

            if ($option->isEmpty()) {
                $result[$key] = $fileData[$key];
                continue;
            }

            $result[$key] = $option->get();
        }

        return $result;
    }
}