FM / Dotenv

/var/www/vhosts/ihelp.ro/httpdocs/vendor/josegonzalez/dotenv/src/josegonzalez/Dotenv/

/var/www/vhosts/ihelp.ro/httpdocs/vendor/josegonzalez/dotenv/src/josegonzalez/Dotenv

Name	Size	Mode	Actions
Filter/	-	0755	rm
Expect.php	1209	0644	edit dl rm
Loader.php	11535	0644	edit dl rm

Edit: /var/www/vhosts/ihelp.ro/httpdocs/vendor/josegonzalez/dotenv/src/josegonzalez/Dotenv/Loader.php (11535B)

<?php

namespace josegonzalez\Dotenv;

use InvalidArgumentException;
use josegonzalez\Dotenv\Expect;
use josegonzalez\Dotenv\Filter\CallableFilter;
use LogicException;
use M1\Env\Parser;

class Loader
{

protected $environment = null;

protected $filepaths = null;

protected $filters = array();

protected $prefix = null;

protected $raise = true;

protected $skip = array(
        'apacheSetenv' => false,
        'define' => false,
        'putenv' => false,
        'toEnv' => false,
        'toServer' => false,
    );

public function __construct($filepaths = null)
    {
        $this->setFilepaths($filepaths);
        return $this;
    }

public static function load($options = null)
    {
        $filepaths = null;
        if (is_string($options)) {
            $filepaths = $options;
            $options = array();
        } elseif (isset($options['filepath'])) {
            $filepaths = (array)$options['filepath'];
            unset($options['filepath']);
        } elseif (isset($options['filepaths'])) {
            $filepaths = $options['filepaths'];
            unset($options['filepaths']);
        }

$dotenv = new \josegonzalez\Dotenv\Loader($filepaths);

if (array_key_exists('raiseExceptions', $options)) {
            $dotenv->raiseExceptions($options['raiseExceptions']);
        }

$dotenv->parse();

if (array_key_exists('filters', $options)) {
            $dotenv->setFilters($options['filters']);
            $dotenv->filter();
        }

$methods = array(
            'skipExisting',
            'prefix',
            'expect',
            'apacheSetenv',
            'define',
            'putenv',
            'toEnv',
            'toServer',
        );
        foreach ($methods as $method) {
            if (array_key_exists($method, $options)) {
                $dotenv->$method($options[$method]);
            }
        }

return $dotenv;
    }

public function filepath()
    {
        return current($this->filepaths);
    }

public function filepaths()
    {
        return $this->filepaths;
    }

public function setFilepath($filepath = null)
    {
        return $this->setFilepaths($filepath);
    }

public function setFilepaths($filepaths = null)
    {
        if ($filepaths == null) {
            $filepaths = array(__DIR__ . DIRECTORY_SEPARATOR . '.env');
        }

if (is_string($filepaths)) {
            $filepaths = array($filepaths);
        }

$this->filepaths = $filepaths;
        return $this;
    }

public function filters()
    {
        return $this->filters;
    }

public function setFilters(array $filters)
    {
        $newList = array();
        $keys = array_keys($filters);
        $count = count($keys);
        for ($i = 0; $i < $count; $i++) {
            if (is_int($keys[$i])) {
                $filter = $filters[$keys[$i]];
                if (is_string($filter)) {
                    $newList[$filter] = null;
                } else {
                    $newList['__callable__' . $i] = array(
                        'callable' => $filter
                    );
                }
            } else {
                $newList[$keys[$i]] = $filters[$keys[$i]];
            }
        }

$this->filters = $newList;

foreach ($this->filters as $filterClass => $config) {
            if (substr($filterClass, 0, 12) === '__callable__') {
                if (is_callable($config['callable'])) {
                    continue;
                }
                return $this->raise(
                    'LogicException',
                    sprintf('Invalid filter class')
                );
            }
            if (is_callable($filterClass)) {
                continue;
            }
            if (!class_exists($filterClass)) {
                return $this->raise(
                    'LogicException',
                    sprintf('Invalid filter class %s', $filterClass)
                );
            }
            continue;
        }
        return $this;
    }

public function filter()
    {
        $this->requireParse('filter');

$environment = $this->environment;
        foreach ($this->filters as $filterClass => $config) {
            $filter = $filterClass;
            if (is_string($filterClass)) {
                if (substr($filterClass, 0, 12) === '__callable__') {
                    $filter = new CallableFilter;
                }
                if (class_exists($filterClass)) {
                    $filter = new $filterClass;
                }
            }
            $environment = $filter($environment, $config);
        }

$this->environment = $environment;
        return $this;
    }

public function parse()
    {
        $contents = false;
        $filepaths = $this->filepaths();

foreach ($filepaths as $i => $filepath) {
            $isLast = count($filepaths) - 1 === $i;
            if (!file_exists($filepath) && $isLast) {
                return $this->raise(
                    'InvalidArgumentException',
                    sprintf("Environment file '%s' is not found", $filepath)
                );
            }

if (is_dir($filepath) && $isLast) {
                return $this->raise(
                    'InvalidArgumentException',
                    sprintf("Environment file '%s' is a directory. Should be a file", $filepath)
                );
            }

if ((!is_readable($filepath) || ($contents = file_get_contents($filepath)) === false) && $isLast) {
                return $this->raise(
                    'InvalidArgumentException',
                    sprintf("Environment file '%s' is not readable", $filepath)
                );
            }

if ($contents !== false) {
                break;
            }
        }

$parser = new Parser($contents);
        $this->environment = $parser->getContent();

return $this;
    }

public function expect()
    {
        $this->requireParse('expect');

$expect = new Expect($this->environment, $this->raise);
        call_user_func_array($expect, func_get_args());

return $this;
    }

public function apacheSetenv($overwrite = false)
    {
        $this->requireParse('apache_setenv');
        foreach ($this->environment as $key => $value) {
            $prefixedKey = $this->prefixed($key);
            if (apache_getenv($prefixedKey) !== false && !$overwrite) {
                if ($this->skip['apacheSetenv']) {
                    continue;
                }

return $this->raise(
                    'LogicException',
                    sprintf('Key "%s" has already been defined in apache_getenv()', $prefixedKey)
                );
            }

apache_setenv($prefixedKey, $value);
        }

return $this;
    }

public function define()
    {
        $this->requireParse('define');
        foreach ($this->environment as $key => $value) {
            $prefixedKey = $this->prefixed($key);
            if (defined($prefixedKey)) {
                if ($this->skip['define']) {
                    continue;
                }

return $this->raise(
                    'LogicException',
                    sprintf('Key "%s" has already been defined', $prefixedKey)
                );
            }

define($prefixedKey, $value);
        }

return $this;
    }

public function putenv($overwrite = false)
    {
        $this->requireParse('putenv');
        foreach ($this->environment as $key => $value) {
            $prefixedKey = $this->prefixed($key);
            if (getenv($prefixedKey) !== false && !$overwrite) {
                if ($this->skip['putenv']) {
                    continue;
                }

return $this->raise(
                    'LogicException',
                    sprintf('Key "%s" has already been defined in getenv()', $prefixedKey)
                );
            }

putenv($prefixedKey . '=' . $value);
        }

return $this;
    }

public function toEnv($overwrite = false)
    {
        $this->requireParse('toEnv');
        foreach ($this->environment as $key => $value) {
            $prefixedKey = $this->prefixed($key);
            if (array_key_exists($prefixedKey, $_ENV) && !$overwrite) {
                if ($this->skip['toEnv']) {
                    continue;
                }

return $this->raise(
                    'LogicException',
                    sprintf('Key "%s" has already been defined in $_ENV', $prefixedKey)
                );
            }

$_ENV[$prefixedKey] = $value;
        }

return $this;
    }

public function toServer($overwrite = false)
    {
        $this->requireParse('toServer');
        foreach ($this->environment as $key => $value) {
            $prefixedKey = $this->prefixed($key);
            if (array_key_exists($prefixedKey, $_SERVER) && !$overwrite) {
                if ($this->skip['toServer']) {
                    continue;
                }

return $this->raise(
                    'LogicException',
                    sprintf('Key "%s" has already been defined in $_SERVER', $prefixedKey)
                );
            }

$_SERVER[$prefixedKey] = $value;
        }

return $this;
    }

public function skipExisting($types = null)
    {
        $args = func_get_args();
        if (isset($args[0]) && is_array($args[0])) {
            $args = $args[0];
        }

$types = (array)$args;
        if (empty($types)) {
            $types = array_keys($this->skip);
        }

foreach ((array)$types as $type) {
            $this->skip[$type] = true;
        }

return $this;
    }

public function skipped()
    {
        $skipped = array();
        foreach ($this->skip as $key => $value) {
            if ($value == true) {
                $skipped[] = $key;
            }
        }
        return $skipped;
    }

public function prefix($prefix = null)
    {
        $this->prefix = $prefix;
        return $this;
    }

public function prefixed($key)
    {
        if (!!$this->prefix) {
            $key = $this->prefix . $key;
        }

return $key;
    }

public function raiseExceptions($raise = true)
    {
        $this->raise = $raise;
        return $this;
    }

public function toArray()
    {
        $this->requireParse('toArray');
        if ($this->environment === null) {
            return null;
        }

$environment = array();
        foreach ($this->environment as $key => $value) {
            $environment[$this->prefixed($key)] = $value;
        }
        return $environment;
    }

public function __toString()
    {
        try {
            $data = $this->toArray();
        } catch (LogicException $e) {
            $data = array();
        }

return json_encode($data);
    }

protected function requireParse($method)
    {
        if (!is_array($this->environment)) {
            return $this->raise(
                'LogicException',
                sprintf('Environment must be parsed before calling %s()', $method)
            );
        }
    }

protected function raise($exception, $message)
    {
        if ($this->raise) {
            throw new $exception($message);
        }

$this->exceptions[] = new $exception($message);
        return false;
    }
}

cmd: