Shopware\Psh\ScriptRuntime\Execution\ProcessEnvironment

Complexity

Total Complexity

17

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	loadDotenvVariables()	0	7	1
A	loadDotenvFile()	0	11	1
A	diffDotenvVarsWithEnv()	0	12	2
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

<?php declare(strict_types=1);

namespace Shopware\Psh\ScriptRuntime\Execution;

use function array_merge;
use Dotenv\Dotenv;
use Dotenv\Environment\DotenvFactory;
use function pathinfo;
use const PATHINFO_BASENAME;
use const PATHINFO_DIRNAME;
use Shopware\Psh\Config\DotenvFile;
use Shopware\Psh\Config\ScriptsPath;
use Symfony\Component\Process\Process;

/**
 * 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 array $constants
     * @param array $variables
     * @param array $templates
     * @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>>.

    }

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

        return $resolvedValues;
    }

    /**
     * @param array $variables
     * @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;
    }

    /**
     * @param array $templates
     * @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;
    }

    /**
     * @param string $shellCommand
     * @return Process
     */
    public function createProcess(string $shellCommand): Process
    {
        return new Process($shellCommand);
    }

    /**
     * @param DotenvFile $dotenvPath
     * @return array
     */
    private function loadDotenvVariables(DotenvFile $dotenvPath): array
    {
        $dotenvFactory = new DotenvFactory();

        $fileData = $this->loadDotenvFile($dotenvPath, $dotenvFactory);
        return $this->diffDotenvVarsWithEnv($fileData, $dotenvFactory);
    }

    /**
     * @param DotenvFile $dotenvPath
     * @param DotenvFactory $dotenvFactory
     * @return array
     */
    private function loadDotenvFile(DotenvFile $dotenvPath, DotenvFactory $dotenvFactory): array
    {
        $filePath = $dotenvPath->getPath();
        $dotenv = Dotenv::create(
            pathinfo($filePath, PATHINFO_DIRNAME),
            pathinfo($filePath, PATHINFO_BASENAME),
            $dotenvFactory
        );

        return $dotenv->load();
    }

    /**
     * @param array $fileData
     * @param DotenvFactory $dotenvFactory
     * @return array
     */
    private function diffDotenvVarsWithEnv(array $fileData, DotenvFactory $dotenvFactory): array
    {
        $fileKeys = array_keys($fileData);
        $result = [];

        $existingVariables = $dotenvFactory->createImmutable();
        foreach ($fileKeys as $key) {
            $result[$key] = $existingVariables->get($key);
        }

        return $result;
    }
}