1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 

<?php

/**
 * MvcCore
 *
 * This source file is subject to the BSD 3 License
 * For the full copyright and license information, please view
 * the LICENSE.md file that are distributed with this source code.
 *
 * @copyright   Copyright (c) 2016 Tom Flidr (https://github.com/mvccore)
 * @license  https://mvccore.github.io/docs/mvccore/5.0.0/LICENCE.md
 */

namespace MvcCore\Config;

trait IniRead {

    /**
     * @inheritDocs
     * @return bool
     */
    public function Read () {
        /** @var $this \MvcCore\Config */
        if ($this->envData) return TRUE;
        /**
         * INI scanner mode. For old PHP versions, lower than `5.6.1`
         * is automatically set to `1`, for higher, where is possible to
         * get INI data automatically type, is set to `2`.
         * Possible values: `1 => INI_SCANNER_RAW, 2 => INI_SCANNER_TYPED`.
         * @var int
         */
        $iniScannerMode = \PHP_VERSION_ID < 50610 ? 1 : 2;
        clearstatcache(TRUE, $this->fullPath);
        $this->lastChanged = filemtime($this->fullPath);
        $rawIniData = parse_ini_file(
            $this->fullPath, TRUE, $iniScannerMode
        );
        if ($rawIniData === FALSE) return FALSE;
        $this->envData = [];
        $allEnvIniDataPlain = static::readAllEnvironmentsSections($rawIniData);
        foreach ($allEnvIniDataPlain as $envName => $envIniData) {
            list($data, $objectTypes) = static::readExpandLevelsAndReType(
                $envIniData, $iniScannerMode
            );
            foreach ($objectTypes as & $objectType)
                if ($objectType[0])
                    $objectType[1] = (object) $objectType[1];
            $this->envData[$envName] = $data;
        }
        
        return TRUE;
    }

    /**
     * Explode all possible sections into environment ini data collections,
     * keyed by environment name. Data, not targeted into any environment,
     * explode into default ini data collection keyed under empty string.
     * @param array $rawIniData
     * @return array
     */
    protected static function & readAllEnvironmentsSections (array & $rawIniData) {
        /** @var $this \MvcCore\Config */
        $allEnvsIniData = [];
        $commonEnvDataKey = static::$commonEnvironmentDataKey;
        $environmentNamesFilter = static::$environmentNamesFilter;
        $sectionNamesFilter = static::$sectionNamesFilter;
        foreach ($rawIniData as $keyOrSectionName => $valueOrSectionValues) {
            $parsedEnvNames = [];
            if (is_array($valueOrSectionValues)) {
                $pos = mb_strpos($keyOrSectionName, '>');
                if ($pos === FALSE) {
                    $key = $keyOrSectionName;
                } else {
                    $envNames = mb_substr($keyOrSectionName, 0, $pos);
                    $envNames = preg_replace($environmentNamesFilter, '', $envNames);
                    $key = mb_substr($keyOrSectionName, $pos + 1);
                    $key = preg_replace($sectionNamesFilter, '', $key);
                    $parsedEnvNames = explode(',', $envNames);
                }
                $newValues = [];
                foreach ($valueOrSectionValues as $subKey => $subValue)
                    $newValues[$key.'.'.$subKey] = $subValue;
            } else {
                $newValues = [$keyOrSectionName => $valueOrSectionValues];
            }
            if (!$parsedEnvNames)
                $parsedEnvNames = [$commonEnvDataKey];
            foreach ($parsedEnvNames as $parsedEnvName) {
                if (!array_key_exists($parsedEnvName, $allEnvsIniData))
                    $allEnvsIniData[$parsedEnvName] = [];
                $allEnvsIniData[$parsedEnvName] = array_merge($allEnvsIniData[$parsedEnvName], $newValues);
            }
        }
        return $allEnvsIniData;
    }

    /**
     * Process single level array with dotted keys into tree structure
     * and complete object type switches about tree records
     * to complete journal about final `\stdClass`es or `array`s types.
     * @param array $iniData
     * @param int   $iniScannerMode
     * @return array
     */
    protected static function readExpandLevelsAndReType (array & $iniData, $iniScannerMode) {
        /** @var $this \MvcCore\Config */
        $result = [];
        $objectTypes = [];
        //$objectTypes[''] = [0, & $result];
        $oldIniScannerMode = $iniScannerMode === 1;// 1 => INI_SCANNER_RAW
        foreach ($iniData as $rawKey => $rawValue) {
            $current = & $result;
            // prepare keys to build levels and configure stdClass/array types
            $rawKeys = [];
            $lastRawKey = $rawKey;
            $lastDotPos = strrpos($rawKey, '.');
            if ($lastDotPos !== FALSE) {
                $rawKeys = explode('.', substr($rawKey, 0, $lastDotPos));
                $lastRawKey = substr($rawKey, $lastDotPos + 1);
            }
            // prepare levels structure and configure stdClass or array type change where necessary
            $absoluteKey = '';
            $prevAbsoluteKey = '';
            foreach ($rawKeys as $key) {
                $prevAbsoluteKey = $absoluteKey;
                $absoluteKey .= ($absoluteKey ? '.' : '') . $key;
                if (!isset($current[$key])) {
                    $keyIsNumeric = is_numeric($key);
                    $current[$key] = [];
                    // object type switch -> array by default:
                    $objectTypes[$absoluteKey] = [0, & $current[$key]];
                    if (isset($objectTypes[$prevAbsoluteKey])) {
                        $objTypesRec = & $objectTypes[$prevAbsoluteKey];
                        if (!$keyIsNumeric && !$objTypesRec[0])
                            // object type switch -> not array anymore:
                            $objTypesRec[0] = 1;
                    }
                }
                $current = & $current[$key];
            }
            // set up value into levels structure and configure type into array if necessary
            if ($oldIniScannerMode) {
                $typedValue = static::readTypedValue($rawValue);
            } else {
                $typedValue = $rawValue;
            }
            if (isset($current[$lastRawKey])) {
                $current[$lastRawKey][] = $typedValue;
            } else {
                if (!is_array($current)) 
                    $current = [$current];
                $current[$lastRawKey] = $typedValue;
            }
            if (!is_numeric($lastRawKey))
                $objectTypes[$absoluteKey][0] = 1;
        }
        return [$result, $objectTypes];
    }

    /**
     * Retype raw INI value into `array` with retyped it's own values or
     * retype raw INI value into `float`, `int` or `string`.
     * @param string|array $rawValue
     * @return array|float|int|string
     */
    protected static function readTypedValue ($rawValue) {
        /** @var $this \MvcCore\Config */
        if (gettype($rawValue) == "array") {
            foreach ($rawValue as $key => $value) {
                $rawValue[$key] = static::readTypedValue($value);
            }
            return $rawValue; // array
        } else if (mb_strlen($rawValue) > 0) {
            if (is_numeric($rawValue)) {
                return static::readTypedValueFloatOrInt($rawValue);
            } else {
                return static::readTypedSpecialValueOrString($rawValue);
            }
        } else {
            return static::readTypedSpecialValueOrString($rawValue);
        }
    }

    /**
     * Retype raw INI value into `float` or `int`.
     * @param string $rawValue
     * @return float|int|string
     */
    protected static function readTypedValueFloatOrInt ($rawValue) {
        /** @var $this \MvcCore\Config */
        if (strpos($rawValue, '.') !== FALSE || strpos($rawValue, 'e') !== FALSE || strpos($rawValue, 'E') !== FALSE) {
            return floatval($rawValue); // float
        } else {
            // int or string if integer is too high (more then PHP max/min: 2147483647/-2147483647)
            $intVal = intval($rawValue);
            return (string) $intVal === $rawValue
                ? $intVal
                : $rawValue;
        }
    }

    /**
     * Retype raw INI value into `bool`, `NULL` or `string`.
     * @param string $rawValue
     * @return bool|NULL|string
     */
    protected static function readTypedSpecialValueOrString ($rawValue) {
        /** @var $this \MvcCore\Config */
        $lowerRawValue = strtolower($rawValue);
        if (isset(static::$specialValues[$lowerRawValue])) {
            return static::$specialValues[$lowerRawValue]; // bool or null
        } else {
            return trim($rawValue); // string
        }
    }
}