Env::getShortCircuit() - Code Metrics - Inspection of "fix getParam logic" - zemit-cms/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( 9ce27f...656c0f )

by Julien
created 2023-03-06 17:05 UTC
Env::getShortCircuit() A

↳ Parent: Env
Complexity

Conditions	1
Paths	1
Size

Total Lines	2
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
eloc	1
c	1
b	1
f	0
dl	0
loc	2
ccs	0
cts	2
cp	0
rs	10
cc	1
nc	1
nop	0
crap	2
<?php
/**
 * This file is part of the Zemit Framework.
 *
 * (c) Zemit Team <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

namespace Zemit\Utils;

use Dotenv\Dotenv;
use Phalcon\Text;

/**
 * Class Env
 * Allow to access environment variable easily
 *
 * Example usage:
 * ```php
 * $this->SET_APPLICATION_ENV('production'); // SET APPLICATION_ENV to 'production'
 * self::SET_APPLICATION_ENV('production'); // SET APPLICATION_ENV to 'production'
 * $this->GET_APPLICATION_ENV('default'); // GET APPLICATION_ENV value or 'default'
 * self::GET_APPLICATION_ENV('default'); // GET APPLICATION_ENV value or 'default'
 * ```
 *
 * @todo fix dotenv mandatory file
 * @author Julien Turbide <[email protected]>
 * @copyright Zemit Team <[email protected]>
 *
 * @since 1.0
 * @version 1.0
 *
 * @package Zemit\Utils
 */
class Env
{
    public static bool $initialized = false;
    
    public static Dotenv $dotenv;
    public static array $vars = [];
    
    public static ?array $paths = null;
    public static array $names = ['.env'];
    public static string $type = 'mutable';
    public static bool $shortCircuit = true;
    public static ?string $fileEncoding = null;
    
    /**
     * Get .env directories
     * @return array
     */
    public static function getPaths() {
        if (is_null(self::$paths)) {
            self::$paths = [];
            foreach (['ENV_PATH', 'ROOT_PATH', 'APP_PATH'] as $constant) {
                if (defined($constant)) {
                    $path = constant($constant);
                    if (!is_null($path)) {
                        self::$paths []= $constant === 'APP_PATH'? dirname($path) : $path;
                        break;
                    }
                }
            }
            if (empty(self::$paths)) {
                self::$paths []= getcwd();
            }
        }
        return self::$paths;
    }
    
    /**
     * Set .env directories
     * @param $paths
     * @return void
     */
    public static function setPaths(array $paths = null): void {
        self::$paths = $paths;
    }
    
    /**
     * Get .env file names
     * @return string|string[]
     */
    public static function getNames() {
        return self::$names;
    }
    
    /**
     * Set .env file names
     * @param $names
     * @return void
     */
    public static function setNames($names = null): void {
        self::$names = $names;
    }
    
    /**
     * Get Dotenv type
     * @return string
     */
    public static function getType() {
        return ucfirst(Text::camelize(strtolower(self::$type ?? 'mutable')));
    }
    
    /**
     * Set Dotenv type
     * @param string|null $type
     * @return void
     */
    public static function setType(?string $type = null): void {
        $domain = ['mutable', 'immutable', 'unsafe-mutable', 'unsafe-immutable'];
        self::$type = (!in_array(strtolower($type), $domain, true)) ? strtolower($type) : 'mutable';
        self::$type = (!in_array(strtolower(/** @scrutinizer ignore-type */ $type), $domain, true)) ? strtolower($type) : 'mutable';
    }
    
    /**
     * @return boolean
     */
    public static function getShortCircuit(): bool {
        return self::$shortCircuit;
    }
    
    /**
     * @param bool $shortCircuit
     * @return void
     */
    public static function setShortCircuit(bool $shortCircuit = true): void {
        self::$shortCircuit = (bool)$shortCircuit;
    }
    
    /**
     * @return ?string
     */
    public static function getFileEncoding(): ?string {
        return self::$fileEncoding;
    }
    
    /**
     * @param ?string $fileEncoding
     * @return void
     */
    public static function setFileEncoding(?string $fileEncoding = null): void {
        self::$fileEncoding = $fileEncoding;
    }
    
    /**
     *
     * @param $paths
     * @param $names
     * @param bool $shortCircuit
     * @param string|null $fileEncoding
     * @param $type
     * @return Dotenv
     */
    public static function initialize($paths = null, $names = null, bool $shortCircuit = null, string $fileEncoding = null, $type = null): Dotenv
    {
        if (!self::$initialized) {
            $type ??= self::getType();
            $paths ??= self::getPaths();
            $names ??= self::getNames();
            $shortCircuit ??= self::getShortCircuit();
            $fileEncoding ??= self::getFileEncoding();
            
            self::$dotenv = Dotenv::{'create'. $type}($paths, $names, $shortCircuit, $fileEncoding);
            self::$vars = self::$dotenv->load();
    
            self::$initialized = true;
        }
        
        return self::$dotenv;
    }
    
    /**
     * @return Dotenv
     */
    public static function getDotenv() {
        return self::$dotenv ?? self::initialize();
    }
    
    /**
     * Get or set the environment variable
     * Ex. (SET): $this->SET_APPLICATION_ENV('production');
     * Ex. (SET): self::SET_APPLICATION_ENV('production');
     * Ex. (SET): Env::SET_APPLICATION_ENV('production');
     * Ex. (GET): $this->GET_APPLICATION_ENV('development');
     * Ex. (GET): self::GET_APPLICATION_ENV('development');
     * Ex. (GET): Env::GET_APPLICATION_ENV('development');
     * @param string $name key to get/set
     * @param mixed $arguments Default fallback value for get, or value to set for set
     * @return mixed Return void for set, and return the environment variable value, or default value for get
     */
    public static function call($name, $arguments)
    {
        $ret = null;

        $getSet = 'set';
        if (strpos($name, 'SET_') === 0) {
            $name = substr($name, 0, 4);
        } elseif (strpos($name, 'set') === 0) {
            $name = substr($name, 0, 3);
        } elseif (strpos($name, 'GET_') === 0) {
            $getSet = 'get';
            $name = substr($name, 0, 4);
        } elseif (strpos($name, 'get') === 0) {
            $getSet = 'get';
            $name = substr($name, 0, 3);
        }
        return self::$getSet($name, array_pop($arguments));
    }
    
    /**
     * Gets the value of an environment variable. Pass the $default for fallback value.
     * @param string $key Key to get
     * @param mixed $default Value to fallback if the key can't be found
     * @return mixed Return the environment variable value or the default value
     */
    public static function get(string $key, $default = null)
    {
        self::getDotenv();
        
        $ret = self::$vars[$key] ?? null;
        $ret ??= is_callable($default)? $default() : $default;
        
        if (is_string($ret)) {
            switch (strtolower($ret)) {
                case 'true':
                    $ret = true;
                    break;
                case 'false':
                    $ret = false;
                    break;
                case 'empty':
                    $ret = '';
                    break;
                case 'null':
                    $ret = null;
                    break;
            }
        }
    
        return $ret;
    }
    
    /**
     * Set an environment variable
     * @param string $key Key to set
     * @param mixed $value Value to set
     */
    public static function set(string $key, $value)
    {
        self::$vars[$key] = $value;
        $_ENV[$key] = $value;
    }
    
    /**
     * Return the environment variable
     * @param string $name Env key to fetch
     * @return mixed Env value
     */
    public function __get(string $name)
    {
        return self::get($name);
    }
    
    /**
     * Set the environment variable
     * @param string $name Env key to set
     * @param mixed $value Value to set
     */
    public function __set(string $name, $value)
    {
        self::set($name, $value);
    }
    
    /**
     * Get or set the environment variable
     * Ex. (SET): self::SET_APPLICATION_ENV('production');
     * Ex. (SET): Env::SET_APPLICATION_ENV('production');
     * Ex. (GET): self::GET_APPLICATION_ENV('development');
     * Ex. (GET): Env::GET_APPLICATION_ENV('development');
     * @param $name string Key to get/set
     * @param $arguments array Default fallback value for get, or value to set for set
     * @return mixed Return void for set, and return the environment variable value, or default value for get
     */
    public static function __callStatic(string $name, array $arguments)
    {
        return self::call($name, $arguments);
    }
    
    /**
     * Get or set the environment variable
     * Ex. (SET): $this->SET_APPLICATION_ENV('production');
     * Ex. (GET): $this->GET_APPLICATION_ENV('development');
     * @param $name string Key to get/set
     * @param $arguments array Default fallback value for get, or value to set for set
     * @return mixed Return void for set, and return the environment variable value, or default value for get
     */
    public function __call(string $name, array $arguments)
    {
        return self::call($name, $arguments);
    }
}

zemit-cms / core

Push — master ( 9ce27f...656c0f )

Env::getShortCircuit() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
