383 lines
9.5 KiB
PHP
383 lines
9.5 KiB
PHP
<?php
|
|
|
|
namespace Dotenv;
|
|
|
|
use Dotenv\Exception\InvalidPathException;
|
|
|
|
/**
|
|
* This is the loaded class.
|
|
*
|
|
* It's responsible for loading variables by reading a file from disk and:
|
|
* - stripping comments beginning with a `#`,
|
|
* - parsing lines that look shell variable setters, e.g `export key = value`, `key="value"`.
|
|
*/
|
|
class Loader
|
|
{
|
|
/**
|
|
* The file path.
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $filePath;
|
|
|
|
/**
|
|
* Are we immutable?
|
|
*
|
|
* @var bool
|
|
*/
|
|
protected $immutable;
|
|
|
|
/**
|
|
* The list of environment variables declared inside the 'env' file.
|
|
*
|
|
* @var array
|
|
*/
|
|
public $variableNames = array();
|
|
|
|
/**
|
|
* Create a new loader instance.
|
|
*
|
|
* @param string $filePath
|
|
* @param bool $immutable
|
|
*
|
|
* @return void
|
|
*/
|
|
public function __construct($filePath, $immutable = false)
|
|
{
|
|
$this->filePath = $filePath;
|
|
$this->immutable = $immutable;
|
|
}
|
|
|
|
/**
|
|
* Set immutable value.
|
|
*
|
|
* @param bool $immutable
|
|
*
|
|
* @return $this
|
|
*/
|
|
public function setImmutable($immutable = false)
|
|
{
|
|
$this->immutable = $immutable;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get immutable value.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function getImmutable()
|
|
{
|
|
return $this->immutable;
|
|
}
|
|
|
|
/**
|
|
* Load `.env` file in given directory.
|
|
*
|
|
* @throws \Dotenv\Exception\InvalidPathException|\Dotenv\Exception\InvalidFileException
|
|
*
|
|
* @return array
|
|
*/
|
|
public function load()
|
|
{
|
|
$this->ensureFileIsReadable();
|
|
|
|
$filePath = $this->filePath;
|
|
$lines = $this->readLinesFromFile($filePath);
|
|
foreach ($lines as $line) {
|
|
if (!$this->isComment($line) && $this->looksLikeSetter($line)) {
|
|
$this->setEnvironmentVariable($line);
|
|
}
|
|
}
|
|
|
|
return $lines;
|
|
}
|
|
|
|
/**
|
|
* Ensures the given filePath is readable.
|
|
*
|
|
* @throws \Dotenv\Exception\InvalidPathException
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function ensureFileIsReadable()
|
|
{
|
|
if (!is_readable($this->filePath) || !is_file($this->filePath)) {
|
|
throw new InvalidPathException(sprintf('Unable to read the environment file at %s.', $this->filePath));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Normalise the given environment variable.
|
|
*
|
|
* Takes value as passed in by developer and:
|
|
* - ensures we're dealing with a separate name and value, breaking apart the name string if needed,
|
|
* - cleaning the value of quotes,
|
|
* - cleaning the name of quotes,
|
|
* - resolving nested variables.
|
|
*
|
|
* @param string $name
|
|
* @param string|null $value
|
|
*
|
|
* @throws \Dotenv\Exception\InvalidFileException
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function normaliseEnvironmentVariable($name, $value)
|
|
{
|
|
list($name, $value) = $this->processFilters($name, $value);
|
|
|
|
$value = $this->resolveNestedVariables($value);
|
|
|
|
return array($name, $value);
|
|
}
|
|
|
|
/**
|
|
* Process the runtime filters.
|
|
*
|
|
* Called from `normaliseEnvironmentVariable` and the `VariableFactory`, passed as a callback in `$this->loadFromFile()`.
|
|
*
|
|
* @param string $name
|
|
* @param string|null $value
|
|
*
|
|
* @throws \Dotenv\Exception\InvalidFileException
|
|
*
|
|
* @return array
|
|
*/
|
|
public function processFilters($name, $value)
|
|
{
|
|
if ($value === null) {
|
|
$value = '';
|
|
}
|
|
|
|
list($name, $value) = $this->splitCompoundStringIntoParts($name, $value);
|
|
list($name, $value) = $this->sanitiseVariableName($name, $value);
|
|
list($name, $value) = $this->sanitiseVariableValue($name, $value);
|
|
|
|
return array($name, $value);
|
|
}
|
|
|
|
/**
|
|
* Read lines from the file, auto detecting line endings.
|
|
*
|
|
* @param string $filePath
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function readLinesFromFile($filePath)
|
|
{
|
|
// Read file into an array of lines with auto-detected line endings
|
|
$autodetect = ini_get('auto_detect_line_endings');
|
|
ini_set('auto_detect_line_endings', '1');
|
|
$lines = file($filePath, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
|
|
ini_set('auto_detect_line_endings', $autodetect);
|
|
|
|
return $lines;
|
|
}
|
|
|
|
/**
|
|
* Determine if the line in the file is a comment, e.g. begins with a #.
|
|
*
|
|
* @param string $line
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected function isComment($line)
|
|
{
|
|
$line = ltrim($line);
|
|
|
|
return isset($line[0]) && $line[0] === '#';
|
|
}
|
|
|
|
/**
|
|
* Determine if the given line looks like it's setting a variable.
|
|
*
|
|
* @param string $line
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected function looksLikeSetter($line)
|
|
{
|
|
return strpos($line, '=') !== false;
|
|
}
|
|
|
|
/**
|
|
* Split the compound string into parts.
|
|
*
|
|
* If the `$name` contains an `=` sign, then we split it into 2 parts, a `name` & `value`
|
|
* disregarding the `$value` passed in.
|
|
*
|
|
* @param string $name
|
|
* @param string $value
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function splitCompoundStringIntoParts($name, $value)
|
|
{
|
|
if (strpos($name, '=') !== false) {
|
|
list($name, $value) = array_map('trim', explode('=', $name, 2));
|
|
}
|
|
|
|
return array($name, $value);
|
|
}
|
|
|
|
/**
|
|
* Strips quotes from the environment variable value.
|
|
*
|
|
* @param string $name
|
|
* @param string $value
|
|
*
|
|
* @throws \Dotenv\Exception\InvalidFileException
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function sanitiseVariableValue($name, $value)
|
|
{
|
|
$value = trim($value);
|
|
if (!$value) {
|
|
return array($name, $value);
|
|
}
|
|
|
|
return array($name, Parser::parseValue($value));
|
|
}
|
|
|
|
/**
|
|
* Resolve the nested variables.
|
|
*
|
|
* Look for ${varname} patterns in the variable value and replace with an
|
|
* existing environment variable.
|
|
*
|
|
* @param string $value
|
|
*
|
|
* @return mixed
|
|
*/
|
|
protected function resolveNestedVariables($value)
|
|
{
|
|
if (strpos($value, '$') !== false) {
|
|
$loader = $this;
|
|
$value = preg_replace_callback(
|
|
'/\${([a-zA-Z0-9_.]+)}/',
|
|
function ($matchedPatterns) use ($loader) {
|
|
$nestedVariable = $loader->getEnvironmentVariable($matchedPatterns[1]);
|
|
if ($nestedVariable === null) {
|
|
return $matchedPatterns[0];
|
|
} else {
|
|
return $nestedVariable;
|
|
}
|
|
},
|
|
$value
|
|
);
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Strips quotes and the optional leading "export " from the environment variable name.
|
|
*
|
|
* @param string $name
|
|
* @param string $value
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function sanitiseVariableName($name, $value)
|
|
{
|
|
return array(Parser::parseName($name), $value);
|
|
}
|
|
|
|
/**
|
|
* Search the different places for environment variables and return first value found.
|
|
*
|
|
* @param string $name
|
|
*
|
|
* @return string|null
|
|
*/
|
|
public function getEnvironmentVariable($name)
|
|
{
|
|
switch (true) {
|
|
case array_key_exists($name, $_ENV):
|
|
return $_ENV[$name];
|
|
case array_key_exists($name, $_SERVER):
|
|
return $_SERVER[$name];
|
|
default:
|
|
$value = getenv($name);
|
|
|
|
return $value === false ? null : $value; // switch getenv default to null
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set an environment variable.
|
|
*
|
|
* This is done using:
|
|
* - putenv,
|
|
* - $_ENV,
|
|
* - $_SERVER.
|
|
*
|
|
* The environment variable value is stripped of single and double quotes.
|
|
*
|
|
* @param string $name
|
|
* @param string|null $value
|
|
*
|
|
* @throws \Dotenv\Exception\InvalidFileException
|
|
*
|
|
* @return void
|
|
*/
|
|
public function setEnvironmentVariable($name, $value = null)
|
|
{
|
|
list($name, $value) = $this->normaliseEnvironmentVariable($name, $value);
|
|
|
|
$this->variableNames[] = $name;
|
|
|
|
// Don't overwrite existing environment variables if we're immutable
|
|
// Ruby's dotenv does this with `ENV[key] ||= value`.
|
|
if ($this->immutable && $this->getEnvironmentVariable($name) !== null) {
|
|
return;
|
|
}
|
|
|
|
// If PHP is running as an Apache module and an existing
|
|
// Apache environment variable exists, overwrite it
|
|
if (function_exists('apache_getenv') && function_exists('apache_setenv') && apache_getenv($name) !== false) {
|
|
apache_setenv($name, $value);
|
|
}
|
|
|
|
if (function_exists('putenv')) {
|
|
putenv("$name=$value");
|
|
}
|
|
|
|
$_ENV[$name] = $value;
|
|
$_SERVER[$name] = $value;
|
|
}
|
|
|
|
/**
|
|
* Clear an environment variable.
|
|
*
|
|
* This is not (currently) used by Dotenv but is provided as a utility
|
|
* method for 3rd party code.
|
|
*
|
|
* This is done using:
|
|
* - putenv,
|
|
* - unset($_ENV, $_SERVER).
|
|
*
|
|
* @param string $name
|
|
*
|
|
* @see setEnvironmentVariable()
|
|
*
|
|
* @return void
|
|
*/
|
|
public function clearEnvironmentVariable($name)
|
|
{
|
|
// Don't clear anything if we're immutable.
|
|
if ($this->immutable) {
|
|
return;
|
|
}
|
|
|
|
if (function_exists('putenv')) {
|
|
putenv($name);
|
|
}
|
|
|
|
unset($_ENV[$name], $_SERVER[$name]);
|
|
}
|
|
}
|