Configurator::build() - Code Metrics - Inspection of "chore: refactorisation du gestionnaire d'exception" - blitz-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — main (#59)

by Dimitri

created 2025-03-12 16:38 UTC

Configurator::build() A

↳ Parent: Configurator

Complexity

Conditions	2
Paths	6

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2.0185

Importance

Changes

Metric	Value
cc	2
eloc	8
c	0
b	0
f	0
nc	6
nop	0
dl	0
loc	12
ccs	5
cts	6
cp	0.8333
crap	2.0185
rs	10

<?php

/**
 * This file is part of Blitz PHP framework.
 *
 * (c) 2022 Dimitri Sitchet Tomkeu <[email protected]>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace BlitzPHP\Config;

use BlitzPHP\Exceptions\ConfigException;
use BlitzPHP\Exceptions\UnknownOptionException;
use Dflydev\DotAccessData\Data;
use Dflydev\DotAccessData\Exception\DataException;
use Dflydev\DotAccessData\Exception\InvalidPathException;
use Dflydev\DotAccessData\Exception\MissingPathException;
use Nette\Schema\Expect;
use Nette\Schema\Processor;
use Nette\Schema\Schema;
use Nette\Schema\ValidationException;
use stdClass;

/**
 * @credit league/config (c) Colin O'Dell <[email protected]>
 */
final class Configurator
{
    /**
     * @psalm-readonly
     */
    private readonly Data $userConfig;

    /**
     * @psalm-allow-private-mutation
     */
    private ?Data $finalConfig = null;

    /**
     * @var array<string, mixed>
     *
     * @psalm-allow-private-mutation
     */
    private array $cache = [];

    /**
     * @param array<string, Schema> $configSchemas
     */
    public function __construct(private array $configSchemas = [])
    {
        $this->userConfig = new Data();

    }

    /**
     * Enregistre un nouveau schéma de configuration à la clé de niveau supérieur donnée
     *
     * @psalm-allow-private-mutation
     */
    public function addSchema(string $key, Schema $schema, bool $overwrite = true): void
    {
        $this->invalidate();

        if ($overwrite || ! isset($this->configSchemas[$key])) {
            $this->configSchemas[$key] = $schema;
        }
    }

    /**
     * @psalm-allow-private-mutation
     */
    public function merge(array $config = []): void
    {
        $this->invalidate();

        $this->userConfig->import($config, Data::REPLACE);
    }

    /**
     * @psalm-allow-private-mutation
     *
     * @param mixed $value
     */
    public function set(string $key, $value): void
    {
        $this->invalidate();

        try {
            $this->userConfig->set($key, $value);
        } catch (DataException $ex) {
            throw new UnknownOptionException($ex->getMessage(), $key, (int) $ex->getCode(), $ex);
        }
    }

    /**
     * @psalm-external-mutation-free
     */
    public function get(string $key)
    {
        if ($this->finalConfig === null) {
            $this->finalConfig = $this->build();
        } elseif (\array_key_exists($key, $this->cache)) {
            return $this->cache[$key];
        }

        try {
            return $this->cache[$key] = $this->finalConfig->get($key);
            return $this->cache[$key] = $this->finalConfig->/** @scrutinizer ignore-call */ get($key);
        } catch (InvalidPathException|MissingPathException $ex) {
            throw new UnknownOptionException($ex->getMessage(), $key, (int) $ex->getCode(), $ex);
        }
    }

    /**
     * @psalm-external-mutation-free
     */
    public function exists(string $key): bool
    {
        if ($this->finalConfig === null) {
            $this->finalConfig = $this->build();
        } elseif (\array_key_exists($key, $this->cache)) {
            return true;
        }

        try {
            return $this->finalConfig->has($key);
        } catch (InvalidPathException) {
            return false;
        }
    }

    /**
     * @psalm-external-mutation-free
     */
    private function invalidate(): void
    {
        $this->cache       = [];
        $this->finalConfig = null;
    }

    /**
     * Applique le schéma à la configuration pour renvoyer la configuration finale
     *
     * @throws ValidationException
     *
     * @psalm-allow-private-mutation
     */
    private function build(): Data
    {
        try {
            $schema    = Expect::structure($this->configSchemas);
            $processor = new Processor();
            $processed = $processor->process($schema, $this->userConfig->export());

            $this->raiseAnyDeprecationNotices($processor->getWarnings());

            return $this->finalConfig = new Data(self::convertStdClassesToArrays($processed));
        } catch (ValidationException $ex) {
            throw new ConfigException($ex->getMessage(), $ex->getCode());
        }
    }

    /**
     * Convertit récursivement les instances stdClass en tableaux
     *
     * @param mixed $data
     *
     * @return mixed
     *
     * @psalm-pure
     */
    private static function convertStdClassesToArrays($data)
    {
        if ($data instanceof stdClass) {
            $data = (array) $data;
        }

        if (\is_array($data)) {
            foreach ($data as $k => $v) {
                $data[$k] = self::convertStdClassesToArrays($v);
            }
        }

        return $data;
    }

    /**
     * @param list<string> $warnings
filter:
    dependency_paths: ["lib/*"]
     */
    private function raiseAnyDeprecationNotices(array $warnings): void
    {
        foreach ($warnings as $warning) {
            @\trigger_error($warning, \E_USER_DEPRECATED);
        }
    }
}


blitz-php / framework

Pull Request — main (#59)

Configurator::build() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like