Final Class Yiisoft\Requirements\RequirementsChecker

                public function check($requirements): self
{
    if (is_string($requirements)) {
        /** @psalm-suppress UnresolvableInclude */
        $requirements = require $requirements;
    }
    if (!is_array($requirements)) {
        $this->usageError('Requirements must be an array, "' . gettype($requirements) . '" has been given!');
    }
    if (!isset($this->result)) {
        $this->result = [
            'summary' => [
                'total' => 0,
                'errors' => 0,
                'warnings' => 0,
            ],
            'requirements' => [],
        ];
    }
    foreach ($requirements as $key => $rawRequirement) {
        if (!is_array($rawRequirement)) {
            $this->usageError(
                'Requirement must be an array, "' . gettype($rawRequirement) . '" has been given!'
            );
        }
        $requirement = $this->normalizeRequirement($rawRequirement, $key);
        $this->result['summary']['total']++;
        if (!$requirement['condition']) {
            if ($requirement['mandatory']) {
                $requirement['error'] = true;
                $requirement['warning'] = true;
                $this->result['summary']['errors']++;
            } else {
                $requirement['error'] = false;
                $requirement['warning'] = true;
                $this->result['summary']['warnings']++;
            }
        } else {
            $requirement['error'] = false;
            $requirement['warning'] = false;
        }
        $this->result['requirements'][] = $requirement;
    }
    return $this;
}

            

                public function checkMaxExecutionTime(?string $max = null): bool
{
    $maxExecutionTime = ini_get('max_exection_time');
    return $max === null || $maxExecutionTime <= $max;
}

            

                public function checkPhpExtensionVersion(string $extensionName, string $version, string $compare = '>='): bool
{
    if (!extension_loaded($extensionName)) {
        return false;
    }
    $extensionVersion = phpversion($extensionName);
    if (empty($extensionVersion)) {
        return false;
    }
    if (strncasecmp($extensionVersion, 'PECL-', 5) === 0) {
        $extensionVersion = substr($extensionVersion, 5);
    }
    /** @var bool */
    return version_compare($extensionVersion, $version, $compare);
}

            

                public function checkPhpIniOff(string $name): bool
{
    $value = ini_get($name);
    if (empty($value)) {
        return true;
    }
    return (strtolower($value) === 'off');
}

            

                public function checkPhpIniOn(string $name): bool
{
    $value = ini_get($name);
    if (empty($value)) {
        return false;
    }
    return ((int) $value === 1 || strtolower($value) === 'on');
}

            

                public function checkUploadMaxFileSize(?string $min = null, ?string $max = null): bool
{
    /**
     * @var string $postMaxSize "post_max_size" option is existed, so `ini_get()` always returns a string.
     */
    $postMaxSize = ini_get('post_max_size');
    /**
     * @var string $uploadMaxFileSize "upload_max_filesize" option is existed, so `ini_get()` always returns
     * a string.
     */
    $uploadMaxFileSize = ini_get('upload_max_filesize');
    if ($min !== null) {
        $minCheckResult = $this->compareByteSize($postMaxSize, $min, '>=') && $this->compareByteSize($uploadMaxFileSize, $min, '>=');
    } else {
        $minCheckResult = true;
    }
    if ($max !== null) {
        $maxCheckResult = $this->compareByteSize($postMaxSize, $max, '<=') && $this->compareByteSize($uploadMaxFileSize, $max, '<=');
    } else {
        $maxCheckResult = true;
    }
    return ($minCheckResult && $maxCheckResult);
}

            

                public function compareByteSize(string $a, string $b, string $compare = '>='): bool
{
    $compareExpression = '(' . $this->getByteSize($a) . $compare . $this->getByteSize($b) . ')';
    /** @var bool */
    return $this->evaluateExpression($compareExpression);
}

            

                public function evaluateExpression(string $expression)
{
    return eval('return ' . $expression . ';');
}

            

                public function getByteSize(string $verboseSize): int
{
    if (empty($verboseSize)) {
        return 0;
    }
    if (is_numeric($verboseSize)) {
        return (int) $verboseSize;
    }
    $sizeUnit = trim($verboseSize, '0123456789');
    $size = trim(str_replace($sizeUnit, '', $verboseSize));
    if (!is_numeric($size)) {
        return 0;
    }
    switch (strtolower($sizeUnit)) {
        case 'kb':
        case 'k':
            return intval($size * 1024);
        case 'mb':
        case 'm':
            return intval($size * 1024 * 1024);
        case 'gb':
        case 'g':
            return intval($size * 1024 * 1024 * 1024);
        default:
            return 0;
    }
}

            

                public function getNowDate(): string
{
    return date('Y-m-d H:i:s');
}

            

                public function getResult(): ?array
{
    return $this->result ?? null;
}

            

                public function getServerInfo(): string
{
    return $_SERVER['SERVER_SOFTWARE'] ?? '';
}

            

                public function normalizeRequirement(array $requirement, $requirementKey = 0): array
{
    if (!array_key_exists('condition', $requirement)) {
        $this->usageError("Requirement \"$requirementKey\" has no condition!");
    } else {
        $evalPrefix = 'eval:';
        if (is_string($requirement['condition']) && strpos($requirement['condition'], $evalPrefix) === 0) {
            $expression = substr($requirement['condition'], strlen($evalPrefix));
            $requirement['condition'] = $this->evaluateExpression($expression);
        }
    }
    if (!array_key_exists('name', $requirement)) {
        $requirement['name'] = is_numeric($requirementKey) ? 'Requirement #' . $requirementKey : $requirementKey;
    }
    if (!array_key_exists('mandatory', $requirement)) {
        if (array_key_exists('required', $requirement)) {
            $requirement['mandatory'] = $requirement['required'];
        } else {
            $requirement['mandatory'] = false;
        }
    }
    if (!array_key_exists('by', $requirement)) {
        $requirement['by'] = 'Unknown';
    }
    if (!array_key_exists('memo', $requirement)) {
        $requirement['memo'] = '';
    }
    return $requirement;
}

            

                public function render(): void
{
    if (!isset($this->result)) {
        $this->usageError('Nothing to render!');
    }
    $baseViewFilePath = __DIR__ . DIRECTORY_SEPARATOR . 'views';
    if (!empty($_SERVER['argv'])) {
        $viewFileName = $baseViewFilePath . DIRECTORY_SEPARATOR . 'console' . DIRECTORY_SEPARATOR . 'index.php';
    } else {
        $viewFileName = $baseViewFilePath . DIRECTORY_SEPARATOR . 'web' . DIRECTORY_SEPARATOR . 'index.php';
    }
    $this->renderViewFile($viewFileName, $this->result);
}

            

                public function renderViewFile(string $_viewFile_, ?array $_data_ = null, bool $_return_ = false): ?string
{
    // we use special variable names here to avoid conflict when extracting data
    if (is_array($_data_)) {
        extract($_data_, EXTR_PREFIX_SAME, 'data');
    } else {
        $data = $_data_;
    }
    if ($_return_) {
        ob_start();
        /**
         * @psalm-suppress InvalidArgument Need for compatibility with PHP 7.4
         */
        PHP_VERSION_ID >= 80000 ? ob_implicit_flush(false) : ob_implicit_flush(0);
        /** @psalm-suppress UnresolvableInclude */
        require $_viewFile_;
        /**
         * @var string In this case active output buffer is always existed, so `ob_get_clean()` returns a string.
         */
        return ob_get_clean();
    }
    /** @psalm-suppress UnresolvableInclude */
    require $_viewFile_;
    return null;
}

            

                public function usageError(string $message): void
{
    echo "Error: $message\n\n";
    exit(1);
}