Yiisoft\Widget\WidgetFactory

Complexity

Total Complexity

17

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Test Coverage

Coverage

96.23%

Importance

Changes	5
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	2	1
A	initialize()	0	14	2
A	setDefaultTheme()	0	3	1
B	assertThemesStructure()	0	36	7
A	createWidget()	0	22	6

<?php

declare(strict_types=1);

namespace Yiisoft\Widget;

use Psr\Container\ContainerInterface;
use Yiisoft\Definitions\ArrayDefinition;
use Yiisoft\Definitions\Exception\CircularReferenceException;
use Yiisoft\Definitions\Exception\InvalidConfigException;
use Yiisoft\Definitions\Exception\NotInstantiableException;
use Yiisoft\Definitions\Helpers\ArrayDefinitionHelper;
use Yiisoft\Definitions\Helpers\DefinitionValidator;
use Yiisoft\Factory\NotFoundException;
use Yiisoft\Factory\Factory;

/**
 * WidgetFactory creates an instance of the widget based on the specified configuration
 * {@see WidgetFactory::createWidget()}. Before creating a widget, you need to initialize
 * the WidgetFactory with {@see WidgetFactory::initialize()}.
 */
final class WidgetFactory
{
    private static ?Factory $factory = null;

    /**
     * @psalm-var array<string, array<string, array>>
     */
    private static array $themes = [];

    private static ?string $defaultTheme = null;

    private function __construct()
    {
    }

    /**
     * @psalm-param array<string, mixed> $definitions
     * @psalm-param array<string, array<string, array>> $themes
     *
     * @throws InvalidConfigException
     *
     * @see Factory::__construct()
     */
    public static function initialize(
        ContainerInterface $container,
        array $definitions = [],
        bool $validate = true,
        array $themes = [],
        ?string $defaultTheme = null,
    ): void {
        self::$factory = new Factory($container, $definitions, $validate);

        if ($validate) {
            self::assertThemesStructure($themes);
        }
        self::$themes = $themes;
        self::$defaultTheme = $defaultTheme;
    }

    public static function setDefaultTheme(?string $theme): void
    {
        self::$defaultTheme = $theme;
    }

    /**
     * Creates a widget defined by config passed.
     *
     * @param array $config The parameters for creating a widget.
     * @param string|null $theme The widget theme.
     *
     * @throws WidgetFactoryInitializationException If factory was not initialized.
     * @throws CircularReferenceException
     * @throws InvalidConfigException
     * @throws NotFoundException
     * @throws NotInstantiableException
     *
     * @see Factory::create()
     *
     * @psalm-suppress MixedInferredReturnType
     * @psalm-suppress MixedReturnStatement
     */
    public static function createWidget(array $config, ?string $theme = null): Widget
    {
        if (self::$factory === null) {
            throw new WidgetFactoryInitializationException(
                'Widget factory should be initialized with WidgetFactory::initialize() call.',
            );
        }

        $theme ??= self::$defaultTheme;

        if ($theme !== null && isset(self::$themes[$theme])) {
            /** @var mixed $className */
            $className = $config[ArrayDefinition::CLASS_NAME] ?? null;
            if (is_string($className) && isset(self::$themes[$theme][$className])) {
                $config = ArrayDefinitionHelper::merge(
                    self::$themes[$theme][$className],
                    $config
                );
            }
        }

        return self::$factory->create($config);
    }

    /**
     * @throws InvalidConfigException
     */
    private static function assertThemesStructure(array $themes): void
    {
        /** @var mixed $definitions */
        foreach ($themes as $theme => $definitions) {
            if (!is_string($theme)) {
                throw new InvalidConfigException(
                    sprintf('Theme name must be a string. Integer value "%s" given.', $theme)
                );
            }
            if (!is_array($definitions)) {
                throw new InvalidConfigException(
                    sprintf(
                        'Theme configuration must be an array. "%s" given for theme "%s".',
                        get_debug_type($definitions),
                        $theme,
                    )
                );
            }
            /** @var mixed $definition */
            foreach ($definitions as $id => $definition) {
                if (!is_string($id)) {
                    throw new InvalidConfigException(
                        sprintf('Widget name must be a string. Integer value "%s" given in theme "%s".', $id, $theme)
                    );
                }
                if (!is_array($definition)) {
                    throw new InvalidConfigException(
                        sprintf(
                            'Widget themes supports array definitions only. "%s" given for "%s" definition in "%s" theme.',
                            get_debug_type($definition),
                            $id,
                            $theme,
                        )
                    );
                }
                DefinitionValidator::validateArrayDefinition($definition, $id);
            }
        }
    }
}