Enjoys\Dotenv\Dotenv

Complexity

Total Complexity

34

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	15
Bugs	1	Features	3

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	loadEnv()	0	14	3
A	clearMemory()	0	3	1
A	writeEnvs()	0	4	2
A	enableCastType()	0	3	1
A	clear()	0	12	4
A	disableCastType()	0	3	1
A	getEnvRawArray()	0	3	1
A	isCastType()	0	3	1
A	populate()	0	16	4
A	getEnvCollection()	0	3	1
A	isClearMemory()	0	3	1
A	isPopulateToServer()	0	3	1
A	handleValue()	0	20	5
A	readFiles()	0	12	5
A	getLoadedPaths()	0	3	1
A	isUsePutEnv()	0	3	1

<?php

declare(strict_types=1);


namespace Enjoys\Dotenv;

use Enjoys\Dotenv\Parser\Parser;
use Enjoys\Dotenv\Parser\ParserInterface;

final class Dotenv
{

    public const CLEAR_MEMORY_AFTER_LOAD_ENV = 1;
    public const CAST_TYPE_ENV_VALUE = 2;
    public const POPULATE_PUTENV = 4;
    public const POPULATE_SERVER = 8;

    private const CHARACTER_MAP = [
        "\\n" => "\n",
        "\\\"" => "\"",
        "\\\\" => "\\",
        '\\\'' => "'",
        '\\t' => "\t"
    ];

    /**
     * @var array<string, string|null>
     */
    private array $envRawArray = [];

    private EnvCollection $envCollection;
    private ParserInterface $parser;
    private Variables $variablesResolver;
    private StorageInterface $storage;

    public function __construct(
        private string $envFilePath,
        ?StorageInterface $storage = null,
        ?ParserInterface $parser = null,
        private int $flags = 0
    ) {
        $this->envCollection = new EnvCollection();
        $this->parser = $parser ?? new Parser();
        $this->storage = $storage ?? new Storage();
        $this->variablesResolver = new Variables($this);
    }

    public function loadEnv(bool $usePutEnv = false): void
    {
        if ($usePutEnv) {
            $this->flags = $this->flags | self::POPULATE_PUTENV;
        }

        $this->readFiles();
        $this->writeEnvs();


        putenv(sprintf('ENJOYS_DOTENV=%s', implode(',', $this->envCollection->getKeys())));

        if ($this->isClearMemory()) {
            $this->clearMemory();
        }
    }

    private function readFiles(): void
    {
        $this->storage->addPath($this->envFilePath . '.dist');
        $this->storage->addPath($this->envFilePath);

        while (false !== $path = $this->storage->getPath()) {
            if (!$this->storage->isLoaded($path)) {
                $contents = file_get_contents($path);
                $this->envRawArray = array_merge($this->envRawArray, $this->parser->parseEnv($contents !== false ? $contents : ''));
                $this->storage->markLoaded($path);
                $this->storage->addPath(
                    $this->envFilePath . '.' . ((getenv('APP_ENV') !== false ? (string)getenv('APP_ENV') : null) ?? $this->envRawArray['APP_ENV'] ?? '')
                );
            }
        }
    }

    private function writeEnvs(): void
    {
        foreach ($this->envRawArray as $key => $value) {
            $this->populate($key, $value);
        }
    }

    public function handleValue(string $key, ?string $value): float|bool|int|string|null
    {
        if ($value !== null) {
            $quoted = null;
            $value = preg_replace_callback('/^(?<quote>[\'"])?(?<value>.*)\1/', function ($matches) {
                return match ($matches['quote']) {
                    "'" => $matches['value'],
                    "\"" => strtr($matches['value'], self::CHARACTER_MAP)
                };
            }, $value, count: $quoted);
        }

        $value = $this->variablesResolver->resolve($key, $value);


        if (getenv($key) !== false) {
            $value = getenv($key);
        }

        return ($this->isCastType() && ($quoted ?? null) === 0) ? ValueTypeCasting::castType($value) : $value;
    }

    public function populate(
        string $key,
        string|null $value,
    ): void {
        $value = $this->handleValue($key, $value);

        $_ENV[$key] = $value;
        $this->envCollection->add($key, $value);


        if (getenv($key) === false && $this->isUsePutEnv() === true) {
            putenv(sprintf("%s=%s", $key, Variables::scalarValueToString($value)));
        }

        if ($this->isPopulateToServer()) {
            $_SERVER[$key] = $value;
        }
    }

    public function getEnvRawArray(): array
    {
        return $this->envRawArray;
    }

    public function getEnvCollection(): EnvCollection
    {
        return $this->envCollection;
    }

    /**
     * @return string[]
     */
    public function getLoadedPaths(): array
    {
        return $this->storage->getLoadedPaths();
    }


    public static function clear(): void
    {
        if (false !== $envs = getenv('ENJOYS_DOTENV')) {
            foreach (explode(',', $envs) as $key) {
                if (!empty($key)) {
                    //unset
                    putenv($key);
                    unset($_ENV[$key], $_SERVER[$key]);
                }
            }
        }
        putenv('ENJOYS_DOTENV');
    }

    public function enableCastType(): void
    {
        $this->flags = $this->flags | self::CAST_TYPE_ENV_VALUE;
    }

    public function disableCastType(): void
    {
        $this->flags = $this->flags ^ self::CAST_TYPE_ENV_VALUE;
    }

    private function clearMemory(): void
    {
        unset($this->envCollection, $this->variablesResolver);
    }

    private function isUsePutEnv(): bool
    {
        return ($this->flags & self::POPULATE_PUTENV) === self::POPULATE_PUTENV;
    }

    private function isPopulateToServer(): bool
    {
        return ($this->flags & self::POPULATE_SERVER) === self::POPULATE_SERVER;
    }

    private function isCastType(): bool
    {
        return ($this->flags & self::CAST_TYPE_ENV_VALUE) === self::CAST_TYPE_ENV_VALUE;
    }

    private function isClearMemory(): bool
    {
        return ($this->flags & self::CLEAR_MEMORY_AFTER_LOAD_ENV) === self::CLEAR_MEMORY_AFTER_LOAD_ENV;
    }

}