BlitzPHP\Loader\Load

Complexity

Total Complexity

18

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	model()	0	21	5
A	helper()	0	10	3
A	providers()	0	20	5
A	getLoaded()	0	3	1
A	loaded()	0	3	1
A	isLoaded()	0	7	3

<?php

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

namespace BlitzPHP\Loader;

use BlitzPHP\Contracts\Database\ConnectionInterface;
use BlitzPHP\Exceptions\LoadException;

class Load
{
    /**
     * Liste des elements deja chargés,
     * Si un element est deja chargé, on le renvoie simplement sans avoir besoin de le construire à nouveau
     *
     * @var array
     */
    private static $loads = [
        'controllers' => [],
        'helpers'     => [],
        'langs'       => [],
        'libraries'   => [],
        'models'      => [],
    ];

    /**
     * Recupere toutes les definitions des services a injecter dans le container
     */
    public static function providers(): array
    {
        $providers = [];

        // services système
        $filename = SYST_PATH . 'Constants' . DS . 'providers.php';
        if (! file_exists($filename)) {
            throw LoadException::providersDefinitionDontExist($filename);
        }
        if (! in_array($filename, get_included_files(), true)) {
            $providers = array_merge($providers, require $filename);
        }

        // services de l'application
        $filename = CONFIG_PATH . 'providers.php';
        if (file_exists($filename) && ! in_array($filename, get_included_files(), true)) {
            $providers = array_merge($providers, require $filename);
        }

        return $providers;
    }

    /**
     * Charge un fichier d'aide
     *
     * @throws InvalidArgumentException
     * @throws LoadException
     */
    public static function helper(string|array $helpers)
    {
        if (empty($helpers)) {
            throw new LoadException('Veuillez specifier le helper à charger');
        }

        $helpers = (array) $helpers;

        foreach ($helpers as $helper) {
            FileLocator::helper($helper);
        }
    }

    /**
     * Charge un modele
     *
     * @return object|object[]
     *
     * @throws LoadException
     */
    public static function model(string|array $model, array $options = [], ?ConnectionInterface $connection = null)
    {
        if (empty($model)) {
            throw new LoadException('Veuillez specifier le modele à charger');
        }

        if (is_array($model)) {

The condition is_array($model) is always true.

            $models = [];

            foreach ($model as $value) {
                $models[] = self::model($value, $options, $connection);
            }

            return $models;

The expression return $models returns an array which contains values of type array<mixed,object> which are incompatible with the documented value type object.

        }

        if (! self::isLoaded('models', $model)) {
            self::loaded('models', $model, FileLocator::model($model, $options, $connection));
        }

        return self::getLoaded('models', $model);
    }

    /**
     * Verifie si un element est chargé dans la liste des modules
     *
     * @param mixed $element
     */
    private static function isLoaded(string $module, $element): bool
    {
        if (! isset(self::$loads[$module]) || ! is_array(self::$loads[$module])) {
            return false;
        }

        return in_array($element, self::$loads[$module], true);
    }

    /**
     * Ajoute un element aux elements chargés
     *
     * @param mixed $value
     */
    private static function loaded(string $module, string $element, $value = null): void
    {
        self::$loads[$module][$element] = $value;
    }

    /**
     * Renvoie un element chargé
     *
     * @param mixed $element
     *
     * @return mixed
     */
    private static function getLoaded(string $module, $element)
    {
        return self::$loads[$module][$element] ?? null;
    }
}