luya\theme\ThemeManager

Complexity

Total Complexity

29

Size/Duplication

Total Lines	236
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
B	loadThemeConfig()	0	23	7
A	setup()	0	16	3
A	beforeSetup()	0	8	1
A	getActiveThemeBasePath()	0	8	3
A	getThemes()	0	15	3
A	getThemeDefinitions()	0	17	4
A	getThemeByBasePath()	0	10	2
A	registerTheme()	0	11	2
A	activate()	0	7	1
A	getActiveTheme()	0	4	1
A	setActiveTheme()	0	4	1
A	getHasActiveTheme()	0	4	1

<?php

namespace luya\theme;

use luya\base\PackageConfig;
use luya\Exception;
use luya\helpers\Json;
use Yii;
use yii\base\InvalidArgumentException;
use yii\base\InvalidConfigException;

/**
 * Core theme manager for LUYA.
 *
 * This component manage available themes via file system and the actual display themes.
 *
 * @property bool $hasActiveTheme
 * @property Theme $activeTheme
 *
 * @author Bennet Klarhölter <boehsermoe@me.com>
 * @since  1.1.0
 */
class ThemeManager extends \yii\base\Component
{
    /**
     * Name of the event before the active theme will be setup.
     */
    const EVENT_BEFORE_SETUP = 'eventBeforeSetup';
    
    /**
     * Name of the theme which should be activated on setup.
     *
     * @var string
     */
    public $activeThemeName;
    
    /**
     * @var ThemeConfig[]
     */
    private $_themes = [];
    
    /**
     * Read the theme.json and create a new \luya\theme\ThemeConfig for the given base path.
     *
     * @param string $basePath
     *
     * @return ThemeConfig
     * @throws Exception
     * @throws InvalidConfigException
     */
    protected static function loadThemeConfig(string $basePath)
    {
        if (strpos($basePath, '@') === 0) {
            $dir = Yii::getAlias($basePath);
        } elseif (strpos($basePath, '/') !== 0) {
            $dir = $basePath = Yii::$app->basePath . DIRECTORY_SEPARATOR . $basePath;
        } else {
            $dir = $basePath;
        }
        
        if (!is_dir($dir) || !is_readable($dir)) {
            throw new Exception('Theme directory not exists or readable: ' . $dir);
        }
        
        $themeFile = $dir . '/theme.json';
        if (!file_exists($themeFile)) {
            throw new InvalidConfigException('Theme config file missing at: ' . $themeFile);
        }
        
        $config = Json::decode(file_get_contents($themeFile)) ?: [];
    
        return new ThemeConfig($basePath, $config);
    }
    
    /**
     * Setup active theme
     *
     * @throws Exception
     * @throws InvalidConfigException
     * @throws \yii\db\Exception
     */
    final public function setup()
    {
        if ($this->activeTheme instanceof Theme) {
            // Active theme already loaded
            return;
        }
        
        $basePath = $this->getActiveThemeBasePath();
        if ($basePath) {

The expression $basePath of type string|false is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

            $this->beforeSetup($basePath);
        
            $themeConfig = $this->getThemeByBasePath($basePath);
            $theme = new Theme($themeConfig);
            $this->activate($theme);
        }
    }
    
    /**
     * Trigger the {{\luya\theme\ThemeManager::EVENT_BEFORE_SETUP}} event.
     *
     * @param string $basePath
     */
    protected function beforeSetup(string &$basePath)
    {
        $event = new SetupEvent();
        $event->basePath = $basePath;
        $this->trigger(self::EVENT_BEFORE_SETUP, $event);
        
        $basePath = $event->basePath;
    }
    
    /**
     * Get base path of active theme.
     *
     * @return string
     * @throws \yii\db\Exception
     */
    protected function getActiveThemeBasePath()
    {
        if (!empty($this->activeThemeName) && is_string($this->activeThemeName)) {
            return $this->activeThemeName;
        }
        
        return false;
    }
    
    /**
     * Get all theme configs as array list.
     *
     * @return ThemeConfig[]
     * @throws Exception
     * @throws InvalidConfigException
     */
    public function getThemes()
    {
        if ($this->_themes) {

The expression $this->_themes of type luya\theme\ThemeConfig[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return $this->_themes;
        }
        
        $themeDefinitions = $this->getThemeDefinitions();
        
        foreach ($themeDefinitions as $themeDefinition) {
            $themeConfig = static::loadThemeConfig($themeDefinition);
            $this->registerTheme($themeConfig);
        }
        
        return $this->_themes;
    }
    
    /**
     * Get theme definitions by search in `@app/themes` and the `Yii::$app->getPackageInstaller()`
     *
     * @return string[]
     */
    protected function getThemeDefinitions()
    {
        $themeDefinitions = [];
        
        if (file_exists(Yii::getAlias('@app/themes'))) {
            foreach (glob(Yii::getAlias('@app/themes/*')) as $dirPath) {
                $themeDefinitions[] = "@app/themes/" . basename($dirPath);
            }
        }
        
        foreach (Yii::$app->getPackageInstaller()->getConfigs() as $config) {
            /** @var PackageConfig $config */
            $themeDefinitions = array_merge($themeDefinitions, $config->themes);
        }
        
        return $themeDefinitions;
    }
    
    /**
     * @param string $basePath
     *
     * @return ThemeConfig
     * @throws Exception
     * @throws InvalidConfigException
     */
    public function getThemeByBasePath(string $basePath)
    {
        $themes = $this->getThemes();
        
        if (!isset($themes[$basePath])) {
            throw new InvalidArgumentException("Theme $basePath could not loaded.");
        }
        
        return $themes[$basePath];
    }
    
    /**
     * Register a theme config and set the path alias with the name of the theme.
     *
     * @param ThemeConfig $themeConfig Base path of the theme.
     *
     * @throws InvalidConfigException
     */
    protected function registerTheme(ThemeConfig $themeConfig)
    {
        $basePath = $themeConfig->getBasePath();
        if (isset($this->_themes[$basePath])) {
            throw new InvalidArgumentException("Theme $basePath already registered.");
        }
        
        $this->_themes[$basePath] = $themeConfig;
        
        Yii::setAlias('@' . basename($basePath) . 'Theme', $basePath);
    }
    
    /**
     * Change the active theme in the \yii\base\View component and set the `activeTheme ` alias to new theme base path.
     *
     * @param Theme $theme
     */
    protected function activate(Theme $theme)
    {
        Yii::$app->view->theme = $theme;
        Yii::setAlias('activeTheme', $theme->basePath);
        
        $this->setActiveTheme($theme);
    }
    
    /**
     * @var Theme|null
     */
    private $_activeTheme;
    
    /**
     * Get the active theme. Null if no theme is activated.
     *
     * @return Theme|null
     */
    public function getActiveTheme()
    {
        return $this->_activeTheme;
    }
    
    /**
     * Change the active theme.
     *
     * @param Theme $theme
     */
    protected function setActiveTheme(Theme $theme)
    {
        $this->_activeTheme = $theme;
    }
    
    /**
     * Check if a theme is activated.
     *
     * @return bool
     */
    public function getHasActiveTheme()
    {
        return $this->getActiveTheme() !== null;
    }
}