Config::isEnabled() - Code Metrics - Inspection of "refactor: configuration options and logic" - Cecilapp/Cecil - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#2148)

by Arnaud

created 2025-04-04 21:19 UTC

Config::isEnabled() B

↳ Parent: Config

Complexity

Conditions	7
Paths	5

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	7

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
cc	7
eloc	9
c	4
b	0
f	0
nc	5
nop	3
dl	0
loc	16
ccs	5
cts	5
cp	1
crap	7
rs	8.8333

<?php

declare(strict_types=1);

/*
 * This file is part of Cecil.
 *
 * Copyright (c) Arnaud Ligny <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cecil;

use Cecil\Exception\ConfigException;
use Dflydev\DotAccessData\Data;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;

/**
 * Class Config.
 */
class Config
{
    /** Configuration is a Data object. */
    protected Data $data;

    /** Default configuration is a Data object. */
    protected Data $default;

    /** Source directory. */
    protected ?string $sourceDir = null;

    /** Destination directory. */
    protected ?string $destinationDir = null;

    /** Languages list as array. */
    protected ?array $languages = null;

    public const PRESERVE = 0;
    public const REPLACE = 1;
    public const MERGE = 2;
    public const LANG_CODE_PATTERN = '([a-z]{2}(-[A-Z]{2})?)'; // "fr" or "fr-FR"
    public const LANG_LOCALE_PATTERN = '[a-z]{2}(_[A-Z]{2})?(_[A-Z]{2})?'; // "fr" or "fr_FR" or "no_NO_NY"

    /**
     * Build the Config object with the default config + the optional given array.
     */
    public function __construct(?array $config = null)
    {
        // default configuration
        $defaultConfigFile = Util\File::getRealPath('../config/default.php');
        $this->default = new Data(include $defaultConfigFile);
        // base configuration
        $baseConfigFile = Util\File::getRealPath('../config/base.php');
        $this->data = new Data(include $baseConfigFile);
        // import config array if provided
        if ($config !== null) {
            $this->import($config);
        }
    }

    /**
     * Imports (and validate) configuration.
     * The mode can be: Config::PRESERVE, Config::REPLACE or Config::MERGE.
     */
    public function import(array $config, $mode = self::MERGE): void
    {
        $this->data->import($config, $mode);
        $this->setFromEnv(); // override configuration with environment variables
        $this->validate();   // validate configuration
    }

    /**
     * Get configuration as an array.
     */
    public function export(): array
    {
        return $this->data->export();
    }

    /**
     * Loads and parse a YAML file.
     */
    public static function loadFile(string $file, bool $ignore = false): array
    {
        if (!Util\File::getFS()->exists($file)) {
            if ($ignore) {
                return [];
            }
            throw new ConfigException(\sprintf('File "%s" does not exist.', $file));
        }
        if (false === $fileContent = Util\File::fileGetContents($file)) {
            throw new ConfigException(\sprintf('Can\'t read file "%s".', $file));
        }
        try {
            return Yaml::parse($fileContent, Yaml::PARSE_DATETIME);
        } catch (ParseException $e) {
            throw new ConfigException(\sprintf('"%s" parsing error: %s', $file, $e->getMessage()));
        }
    }

    /**
     * Is configuration's key exists?
     *
     * @param string $key      Configuration key
     * @param string $language Language code (optional)
     * @param bool   $fallback Set to false to not return the value in the default language as fallback
     */
    public function has(string $key, ?string $language = null, bool $fallback = true): bool
    {
        $default = $this->default->has($key);

        if ($language !== null) {
            $langIndex = $this->getLanguageIndex($language);
            $keyLang = "languages.$langIndex.config.$key";
            if ($this->data->has($keyLang)) {
                return true;
            }
            if ($language !== $this->getLanguageDefault() && $fallback === false) {
                return $default;
            }
        }
        if ($this->data->has($key)) {
            return true;
        }

        return $default;
    }

    /**
     * Get the value of a configuration's key.
     *
     * @param string $key      Configuration key
     * @param string $language Language code (optional)
     * @param bool   $fallback Set to false to not return the value in the default language as fallback
     *
     * @return mixed|null
     */
    public function get(string $key, ?string $language = null, bool $fallback = true)
    {
        $default = $this->default->has($key) ? $this->default->get($key) : null;
        if ($language !== null) {
            $langIndex = $this->getLanguageIndex($language);
            $keyLang = "languages.$langIndex.config.$key";
            if ($this->data->has($keyLang)) {
                return $this->data->get($keyLang);
            }
            if ($language !== $this->getLanguageDefault() && $fallback === false) {
                return $default;
            }
        }
        if ($this->data->has($key)) {
            return $this->data->get($key);
        }

        return $default;
    }

    /**
     * Is an option is enabled?
     * Checks if the key is set to `false` or if subkey `enabled` is set to `false`.
     */
    public function isEnabled(string $key, ?string $language = null, bool $fallback = true): bool
    {
        if ($this->has($key, $language, $fallback) && $this->get($key, $language, $fallback) === true) {
            return true;
        }
        if ($this->has("$key.enabled", $language, $fallback)) {
            if ($this->get("$key.enabled", $language, $fallback) === true) {
                return true;
            }
            return false;
        }
        if ($this->has($key, $language, $fallback) && $this->get($key, $language, $fallback) !== false) {
            return true;
        }

        return false;
    }

    /**
     * Set the source directory.
     *
     * @throws \InvalidArgumentException
     */
    public function setSourceDir(string $sourceDir): self
    {
        if (!is_dir($sourceDir)) {
            throw new \InvalidArgumentException(\sprintf('The directory "%s" is not a valid source.', $sourceDir));
        }
        $this->sourceDir = $sourceDir;

        return $this;
    }

    /**
     * Get the source directory.
     */
    public function getSourceDir(): string
    {
        if ($this->sourceDir === null) {
            return getcwd();
        }

        return $this->sourceDir;
    }

    /**
     * Set the destination directory.
     *
     * @throws \InvalidArgumentException
     */
    public function setDestinationDir(string $destinationDir): self
    {
        if (!is_dir($destinationDir)) {
            throw new \InvalidArgumentException(\sprintf('The directory "%s" is not a valid destination.', $destinationDir));
        }
        $this->destinationDir = $destinationDir;

        return $this;
    }

    /**
     * Get the destination directory.
     */
    public function getDestinationDir(): string
    {
        if ($this->destinationDir === null) {
            return $this->getSourceDir();
        }

        return $this->destinationDir;
    }

    /*
     * Path helpers.
     */

    /**
     * Returns the path of the pages directory.
     */
    public function getPagesPath(): string
    {
        return Util::joinFile($this->getSourceDir(), (string) $this->get('pages.dir'));
    }

    /**
     * Returns the path of the output directory.
     */
    public function getOutputPath(): string
    {
        return Util::joinFile($this->getDestinationDir(), (string) $this->get('output.dir'));
    }

    /**
     * Returns the path of the data directory.
     */
    public function getDataPath(): string
    {
        return Util::joinFile($this->getSourceDir(), (string) $this->get('data.dir'));
    }

    /**
     * Returns the path of templates directory.
     */
    public function getLayoutsPath(): string
    {
        return Util::joinFile($this->getSourceDir(), (string) $this->get('layouts.dir'));
    }

    /**
     * Returns the path of internal templates directory.
     */
    public function getLayoutsInternalPath(): string
    {
        return __DIR__ . '/../resources/layouts';
    }

    /**
     * Returns the layout for a section.
     */
    public function getLayoutSection(?string $section): ?string
    {
        if ($layout = $this->get('layouts.sections')[$section] ?? null) {
            return $layout;
        }

        return $section;
    }

    /**
     * Returns the path of translations directory.
     */
    public function getTranslationsPath(): string
    {
        return Util::joinFile($this->getSourceDir(), (string) $this->get('layouts.translations.dir'));
    }

    /**
     * Returns the path of internal translations directory.
     */
    public function getTranslationsInternalPath(): string
    {
        return Util\File::getRealPath('../resources/translations');
    }

    /**
     * Returns the path of themes directory.
     */
    public function getThemesPath(): string
    {
        return Util::joinFile($this->getSourceDir(), 'themes');
    }

    /**
     * Returns the path of static files directory.
     */
    public function getStaticPath(): string
    {
        return Util::joinFile($this->getSourceDir(), (string) $this->get('static.dir'));
    }

    /**
     * Returns the path of static files directory, with a target.
     */
    public function getStaticTargetPath(): string
    {
        $path = $this->getStaticPath();
        if (!empty($this->get('static.target'))) {
            $path = substr($path, 0, -\strlen((string) $this->get('static.target')));
        }

        return $path;
    }

    /**
     * Returns the path of assets files directory.
     */
    public function getAssetsPath(): string
    {
        return Util::joinFile($this->getSourceDir(), (string) $this->get('assets.dir'));
    }

    /**
     * Returns the path of remote assets files directory (in cache).
     *
     * @return string
     */
    public function getAssetsRemotePath(): string
    {
        return Util::joinFile($this->getCacheAssetsPath(), 'remote');
    }

    /**
     * Returns cache path.
     *
     * @throws ConfigException
     */
    public function getCachePath(): string
    {
        if (empty((string) $this->get('cache.dir'))) {
            throw new ConfigException(\sprintf('The cache directory (`%s`) is not defined.', 'cache.dir'));
        }
        if ($this->isCacheDirIsAbsolute()) {
            $cacheDir = Util::joinFile((string) $this->get('cache.dir'), 'cecil');
            Util\File::getFS()->mkdir($cacheDir);

            return $cacheDir;
        }

        return Util::joinFile($this->getDestinationDir(), (string) $this->get('cache.dir'));
    }

    /**
     * Returns cache path of templates.
     */
    public function getCacheTemplatesPath(): string
    {
        return Util::joinFile($this->getCachePath(), 'templates');
    }

    /**
     * Returns cache path of translations.
     */
    public function getCacheTranslationsPath(): string
    {
        return Util::joinFile($this->getCachePath(), 'translations');
    }

    /**
     * Returns cache path of assets.
     */
    public function getCacheAssetsPath(): string
    {
        return Util::joinFile($this->getCachePath(), 'assets');
    }

    /**
     * Returns cache path of assets files.
     */
    public function getCacheAssetsFilesPath(): string
    {
        return Util::joinFile($this->getCacheAssetsPath(), 'files');
    }

    /*
     * Output helpers.
     */

    /**
     * Returns the property value of an output format.
     *
     * @throws ConfigException
     */
    public function getOutputFormatProperty(string $name, string $property): string|array|null
    {
        $properties = array_column((array) $this->get('output.formats'), $property, 'name');
        if (empty($properties)) {
            throw new ConfigException(\sprintf('Property "%s" is not defined for format "%s".', $property, $name));
        }

        return $properties[$name] ?? null;
    }

    /*
     * Assets helpers.
     */

    /**
     * Returns asset image widths.
     */
    public function getAssetsImagesWidths(): array
    {
        return $this->get('assets.images.responsive.widths');
    }

    /**
     * Returns asset image sizes.
     */
    public function getAssetsImagesSizes(): array
    {
        return $this->get('assets.images.responsive.sizes');
    }

    /*
     * Theme helpers.
     */

    /**
     * Returns theme(s) as an array.
     */
    public function getTheme(): ?array
    {
        if ($themes = $this->get('theme')) {
            if (\is_array($themes)) {
                return $themes;
            }

            return [$themes];
        }

        return null;
    }

    /**
     * Has a (valid) theme(s)?
     *
     * @throws ConfigException
     */
    public function hasTheme(): bool
    {
        if ($themes = $this->getTheme()) {
            foreach ($themes as $theme) {
                if (!Util\File::getFS()->exists($this->getThemeDirPath($theme, 'layouts')) && !Util\File::getFS()->exists(Util::joinFile($this->getThemesPath(), $theme, 'config.yml'))) {
                    throw new ConfigException(\sprintf('Theme "%s" not found. Did you forgot to install it?', $theme));
                }
            }

            return true;
        }

        return false;
    }

    /**
     * Returns the path of a specific theme's directory.
     * ("layouts" by default).
     */
    public function getThemeDirPath(string $theme, string $dir = 'layouts'): string
    {
        return Util::joinFile($this->getThemesPath(), $theme, $dir);
    }

    /*
     * Language helpers.
     */

    /**
     * Returns an array of available languages.
     *
     * @throws ConfigException
     */
    public function getLanguages(): array
    {
        if ($this->languages !== null) {
            return $this->languages;
        }
        $languages = array_filter((array) $this->get('languages'), function ($language) {
            return !(isset($language['enabled']) && $language['enabled'] === false);
        });
        if (!\is_int(array_search($this->getLanguageDefault(), array_column($languages, 'code')))) {
            throw new ConfigException(\sprintf('The default language "%s" is not listed in "languages".', $this->getLanguageDefault()));
        }
        $this->languages = $languages;

        return $this->languages;
    }

    /**
     * Returns the default language code (ie: "en", "fr-FR", etc.).
     *
     * @throws ConfigException
     */
    public function getLanguageDefault(): string
    {
        if (!$this->get('language')) {
            throw new ConfigException('There is no default "language" key.');
        }
        if (\is_array($this->get('language'))) {
            if (!$this->get('language.code')) {
                throw new ConfigException('There is no "language.code" key.');
            }

            return $this->get('language.code');
        }

        return $this->get('language');
    }

    /**
     * Returns a language code index.
     *
     * @throws ConfigException
     */
    public function getLanguageIndex(string $code): int
    {
        $array = array_column($this->getLanguages(), 'code');
        if (false === $index = array_search($code, $array)) {
            throw new ConfigException(\sprintf('The language code "%s" is not defined.', $code));
        }

        return $index;
    }

    /**
     * Returns the property value of a (specified or the default) language.
     *
     * @throws ConfigException
     */
    public function getLanguageProperty(string $property, ?string $code = null): string
    {
        $code = $code ?? $this->getLanguageDefault();
        $properties = array_column($this->getLanguages(), $property, 'code');
        if (empty($properties)) {
            throw new ConfigException(\sprintf('Property "%s" is not defined for language "%s".', $property, $code));
        }

        return $properties[$code];
    }

    /*
     * Cache helpers.
     */

    /**
     * Is cache dir is absolute to system files
     * or relative to project destination?
     */
    public function isCacheDirIsAbsolute(): bool
    {
        $path = (string) $this->get('cache.dir');
        if (Util::joinFile($path) == realpath(Util::joinFile($path))) {
            return true;
        }

        return false;
    }

    /*
     * Private functions.
     */

    /**
     * Set configuration from environment variables starting with "CECIL_".
     */
    private function setFromEnv(): void
    {
        foreach (getenv() as $key => $value) {
            if (str_starts_with($key, 'CECIL_')) {
                $this->data->set(str_replace(['cecil_', '_'], ['', '.'], strtolower($key)), $this->castSetValue($value));
            }
        }
    }

    /**
     * Casts boolean value given to set() as string.
     *
     * @param mixed $value
     *
     * @return bool|mixed
     */
    private function castSetValue($value)
    {
        $filteredValue = filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);

        if ($filteredValue !== null) {
            return $filteredValue;
        }

        return $value;
    }

    /**
     * Validate the configuration.
     *
     * @throws ConfigException
     */
    private function validate(): void
    {
        // default language must be valid
        if (!preg_match('/^' . Config::LANG_CODE_PATTERN . '$/', $this->getLanguageDefault())) {
            throw new ConfigException(\sprintf('Default language code "%s" is not valid (e.g.: "language: fr-FR").', $this->getLanguageDefault()));
        }
        // if language is set then the locale is required and must be valid
        foreach ((array) $this->get('languages') as $lang) {
            if (!isset($lang['locale'])) {
                throw new ConfigException('A language locale is not defined.');
            }
            if (!preg_match('/^' . Config::LANG_LOCALE_PATTERN . '$/', $lang['locale'])) {
                throw new ConfigException(\sprintf('The language locale "%s" is not valid (e.g.: "locale: fr_FR").', $lang['locale']));
            }
        }

        // check for deprecated options
        $deprecatedConfigFile = Util\File::getRealPath('../config/deprecated.php');
        $deprecatedConfig = require $deprecatedConfigFile;
        array_walk($deprecatedConfig, function ($to, $from) {
            if ($this->has($from)) {
                if (empty($to)) {
                    throw new ConfigException("Option `$from` is deprecated and must be removed.");
                }
                $path = explode(':', $to);
                $step = 0;
                $formatedPath = '';
                foreach ($path as $fragment) {
                    $step = $step + 2;
                    $formatedPath .= "$fragment:\n" . str_pad(' ', $step);
                }
                throw new ConfigException("Option `$from` must be moved to:\n```\n$formatedPath\n```");
            }
        });
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		/*
6		* This file is part of Cecil.
7		*
8		* Copyright (c) Arnaud Ligny <[email protected]>
9		*
10		* For the full copyright and license information, please view the LICENSE
11		* file that was distributed with this source code.
12		*/
13
14		namespace Cecil;
15
16		use Cecil\Exception\ConfigException;
17		use Dflydev\DotAccessData\Data;
18		use Symfony\Component\Yaml\Exception\ParseException;
19		use Symfony\Component\Yaml\Yaml;
20
21		/**
22		* Class Config.
23		*/
24		class Config
25		{
26		/** Configuration is a Data object. */
27		protected Data $data;
28
29		/** Default configuration is a Data object. */
30		protected Data $default;
31
32		/** Source directory. */
33		protected ?string $sourceDir = null;
34
35		/** Destination directory. */
36		protected ?string $destinationDir = null;
37
38		/** Languages list as array. */
39		protected ?array $languages = null;
40
41		public const PRESERVE = 0;
42		public const REPLACE = 1;
43		public const MERGE = 2;
44		public const LANG_CODE_PATTERN = '([a-z]{2}(-[A-Z]{2})?)'; // "fr" or "fr-FR"
45		public const LANG_LOCALE_PATTERN = '[a-z]{2}(_[A-Z]{2})?(_[A-Z]{2})?'; // "fr" or "fr_FR" or "no_NO_NY"
46
47		/**
48		* Build the Config object with the default config + the optional given array.
49	1	*/
50		public function __construct(?array $config = null)
51		{
52	1	// default configuration
53	1	$defaultConfigFile = Util\File::getRealPath('../config/default.php');
54		$this->default = new Data(include $defaultConfigFile);
55		// base configuration
56	1	$baseConfigFile = Util\File::getRealPath('../config/base.php');
57		$this->data = new Data(include $baseConfigFile);
58		// import config array if provided
59	1	if ($config !== null) {
60	1	$this->import($config);
61		}
62		}
63	1
64		/**
65		* Imports (and validate) configuration.
66	1	* The mode can be: Config::PRESERVE, Config::REPLACE or Config::MERGE.
67		*/
68		public function import(array $config, $mode = self::MERGE): void
69		{
70		$this->data->import($config, $mode);
71		$this->setFromEnv(); // override configuration with environment variables
72	1	$this->validate(); // validate configuration
73		}
74	1
75	1	/**
76	1	* Get configuration as an array.
77		*/
78		public function export(): array
79		{
80		return $this->data->export();
81		}
82
83		/**
84		* Loads and parse a YAML file.
85		*/
86		public static function loadFile(string $file, bool $ignore = false): array
87		{
88		if (!Util\File::getFS()->exists($file)) {
89		if ($ignore) {
90		return [];
91		}
92		throw new ConfigException(\sprintf('File "%s" does not exist.', $file));
93		}
94	1	if (false === $fileContent = Util\File::fileGetContents($file)) {
95		throw new ConfigException(\sprintf('Can\'t read file "%s".', $file));
96	1	}
97		try {
98	1	return Yaml::parse($fileContent, Yaml::PARSE_DATETIME);
99		} catch (ParseException $e) {
100		throw new ConfigException(\sprintf('"%s" parsing error: %s', $file, $e->getMessage()));
101		}
102		}
103
104		/**
105		* Is configuration's key exists?
106		*
107		* @param string $key Configuration key
108	1	* @param string $language Language code (optional)
109	1	* @param bool $fallback Set to false to not return the value in the default language as fallback
110		*/
111		public function has(string $key, ?string $language = null, bool $fallback = true): bool
112	1	{
113		$default = $this->default->has($key);
114
115		if ($language !== null) {
116		$langIndex = $this->getLanguageIndex($language);
117		$keyLang = "languages.$langIndex.config.$key";
118		if ($this->data->has($keyLang)) {
119		return true;
120		}
121		if ($language !== $this->getLanguageDefault() && $fallback === false) {
122		return $default;
123		}
124	1	}
125		if ($this->data->has($key)) {
126	1	return true;
127		}
128	1
129	1	return $default;
130	1	}
131	1
132	1	/**
133		* Get the value of a configuration's key.
134	1	*
135	1	* @param string $key Configuration key
136		* @param string $language Language code (optional)
137		* @param bool $fallback Set to false to not return the value in the default language as fallback
138	1	*
139	1	* @return mixed\|null
140		*/
141		public function get(string $key, ?string $language = null, bool $fallback = true)
142	1	{
143		$default = $this->default->has($key) ? $this->default->get($key) : null;
144		if ($language !== null) {
145		$langIndex = $this->getLanguageIndex($language);
146		$keyLang = "languages.$langIndex.config.$key";
147		if ($this->data->has($keyLang)) {
148		return $this->data->get($keyLang);
149		}
150	1	if ($language !== $this->getLanguageDefault() && $fallback === false) {
151		return $default;
152	1	}
153	1	}
154		if ($this->data->has($key)) {
155	1	return $this->data->get($key);
156		}
157
158	1	return $default;
159		}
160	1
161		/**
162		* Is an option is enabled?
163		* Checks if the key is set to `false` or if subkey `enabled` is set to `false`.
164		*/
165		public function isEnabled(string $key, ?string $language = null, bool $fallback = true): bool
166	1	{
167		if ($this->has($key, $language, $fallback) && $this->get($key, $language, $fallback) === true) {
168	1	return true;
169		}
170		if ($this->has("$key.enabled", $language, $fallback)) {
171		if ($this->get("$key.enabled", $language, $fallback) === true) {
172		return true;
173		}
174		return false;
175		}
176	1	if ($this->has($key, $language, $fallback) && $this->get($key, $language, $fallback) !== false) {
177		return true;
178	1	}
179	1
180		return false;
181	1	}
182
183		/**
184	1	* Set the source directory.
185		*
186	1	* @throws \InvalidArgumentException
187		*/
188		public function setSourceDir(string $sourceDir): self
189		{
190		if (!is_dir($sourceDir)) {
191		throw new \InvalidArgumentException(\sprintf('The directory "%s" is not a valid source.', $sourceDir));
192	1	}
193		$this->sourceDir = $sourceDir;
194	1
195		return $this;
196		}
197
198		/**
199		* Get the source directory.
200		*/
201		public function getSourceDir(): string
202		{
203		if ($this->sourceDir === null) {
204	1	return getcwd();
205		}
206	1
207		return $this->sourceDir;
208		}
209
210		/**
211		* Set the destination directory.
212	1	*
213		* @throws \InvalidArgumentException
214	1	*/
215		public function setDestinationDir(string $destinationDir): self
216		{
217		if (!is_dir($destinationDir)) {
218		throw new \InvalidArgumentException(\sprintf('The directory "%s" is not a valid destination.', $destinationDir));
219		}
220	1	$this->destinationDir = $destinationDir;
221
222	1	return $this;
223		}
224
225		/**
226		* Get the destination directory.
227		*/
228	1	public function getDestinationDir(): string
229		{
230	1	if ($this->destinationDir === null) {
231		return $this->getSourceDir();
232		}
233
234		return $this->destinationDir;
235		}
236	1
237		/*
238	1	* Path helpers.
239		*/
240
241		/**
242		* Returns the path of the pages directory.
243		*/
244	1	public function getPagesPath(): string
245		{
246	1	return Util::joinFile($this->getSourceDir(), (string) $this->get('pages.dir'));
247		}
248
249		/**
250	1	* Returns the path of the output directory.
251		*/
252		public function getOutputPath(): string
253		{
254		return Util::joinFile($this->getDestinationDir(), (string) $this->get('output.dir'));
255		}
256	1
257		/**
258	1	* Returns the path of the data directory.
259		*/
260		public function getDataPath(): string
261		{
262		return Util::joinFile($this->getSourceDir(), (string) $this->get('data.dir'));
263		}
264	1
265		/**
266	1	* Returns the path of templates directory.
267		*/
268		public function getLayoutsPath(): string
269		{
270	1	return Util::joinFile($this->getSourceDir(), (string) $this->get('layouts.dir'));
271		}
272
273		/**
274		* Returns the path of internal templates directory.
275		*/
276	1	public function getLayoutsInternalPath(): string
277		{
278	1	return __DIR__ . '/../resources/layouts';
279		}
280
281		/**
282		* Returns the layout for a section.
283		*/
284	1	public function getLayoutSection(?string $section): ?string
285		{
286	1	if ($layout = $this->get('layouts.sections')[$section] ?? null) {
287		return $layout;
288		}
289
290		return $section;
291		}
292	1
293		/**
294	1	* Returns the path of translations directory.
295		*/
296	1	public function getTranslationsPath(): string
297		{
298		return Util::joinFile($this->getSourceDir(), (string) $this->get('layouts.translations.dir'));
299		}
300	1
301		/**
302		* Returns the path of internal translations directory.
303		*/
304		public function getTranslationsInternalPath(): string
305		{
306	1	return Util\File::getRealPath('../resources/translations');
307		}
308	1
309		/**
310		* Returns the path of themes directory.
311		*/
312		public function getThemesPath(): string
313		{
314		return Util::joinFile($this->getSourceDir(), 'themes');
315		}
316	1
317		/**
318	1	* Returns the path of static files directory.
319		*/
320		public function getStaticPath(): string
321		{
322		return Util::joinFile($this->getSourceDir(), (string) $this->get('static.dir'));
323		}
324
325		/**
326	1	* Returns the path of static files directory, with a target.
327		*/
328	1	public function getStaticTargetPath(): string
329		{
330		$path = $this->getStaticPath();
331		if (!empty($this->get('static.target'))) {
332	1	$path = substr($path, 0, -\strlen((string) $this->get('static.target')));
333		}
334
335		return $path;
336		}
337
338		/**
339	1	* Returns the path of assets files directory.
340		*/
341		public function getAssetsPath(): string
342		{
343		return Util::joinFile($this->getSourceDir(), (string) $this->get('assets.dir'));
344		}
345	1
346		/**
347	1	* Returns the path of remote assets files directory (in cache).
348		*
349		* @return string
350		*/
351		public function getAssetsRemotePath(): string
352		{
353	1	return Util::joinFile($this->getCacheAssetsPath(), 'remote');
354		}
355	1
356		/**
357		* Returns cache path.
358		*
359		* @throws ConfigException
360		*/
361	1	public function getCachePath(): string
362		{
363	1	if (empty((string) $this->get('cache.dir'))) {
364		throw new ConfigException(\sprintf('The cache directory (`%s`) is not defined.', 'cache.dir'));
365		}
366		if ($this->isCacheDirIsAbsolute()) {
367		$cacheDir = Util::joinFile((string) $this->get('cache.dir'), 'cecil');
368		Util\File::getFS()->mkdir($cacheDir);
369	1
370		return $cacheDir;
371	1	}
372
373		return Util::joinFile($this->getDestinationDir(), (string) $this->get('cache.dir'));
374		}
375
376		/**
377		* Returns cache path of templates.
378		*/
379		public function getCacheTemplatesPath(): string
380		{
381		return Util::joinFile($this->getCachePath(), 'templates');
382		}
383	1
384		/**
385	1	* Returns cache path of translations.
386		*/
387	1	public function getCacheTranslationsPath(): string
388		{
389		return Util::joinFile($this->getCachePath(), 'translations');
390		}
391	1
392		/**
393		* Returns cache path of assets.
394		*/
395		public function getCacheAssetsPath(): string
396		{
397		return Util::joinFile($this->getCachePath(), 'assets');
398		}
399
400		/**
401	1	* Returns cache path of assets files.
402		*/
403	1	public function getCacheAssetsFilesPath(): string
404		{
405		return Util::joinFile($this->getCacheAssetsPath(), 'files');
406		}
407
408		/*
409	1	* Output helpers.
410		*/
411	1
412		/**
413		* Returns the property value of an output format.
414		*
415		* @throws ConfigException
416		*/
417		public function getOutputFormatProperty(string $name, string $property): string\|array\|null
418		{
419		$properties = array_column((array) $this->get('output.formats'), $property, 'name');
420		if (empty($properties)) {
421	1	throw new ConfigException(\sprintf('Property "%s" is not defined for format "%s".', $property, $name));
422		}
423	1
424	1	return $properties[$name] ?? null;
425	1	}
426
427		/*
428		* Assets helpers.
429		*/
430
431		/**
432		* Returns asset image widths.
433		*/
434		public function getAssetsImagesWidths(): array
435		{
436		return $this->get('assets.images.responsive.widths');
437		}
438
439	1	/**
440		* Returns asset image sizes.
441	1	*/
442	1	public function getAssetsImagesSizes(): array
443	1	{
444		return $this->get('assets.images.responsive.sizes');
445		}
446
447		/*
448	1	* Theme helpers.
449		*/
450
451		/**
452		* Returns theme(s) as an array.
453		*/
454		public function getTheme(): ?array
455		{
456		if ($themes = $this->get('theme')) {
457		if (\is_array($themes)) {
458	1	return $themes;
459		}
460	1
461		return [$themes];
462		}
463
464		return null;
465		}
466
467		/**
468		* Has a (valid) theme(s)?
469		*
470		* @throws ConfigException
471		*/
472	1	public function hasTheme(): bool
473		{
474	1	if ($themes = $this->getTheme()) {
475	1	foreach ($themes as $theme) {
476		if (!Util\File::getFS()->exists($this->getThemeDirPath($theme, 'layouts')) && !Util\File::getFS()->exists(Util::joinFile($this->getThemesPath(), $theme, 'config.yml'))) {
477		throw new ConfigException(\sprintf('Theme "%s" not found. Did you forgot to install it?', $theme));
478	1	}
479	1	}
480	1
481		return true;
482	1	}
483
484		return false;
485		}
486	1
487		/**
488	1	* Returns the path of a specific theme's directory.
489		* ("layouts" by default).
490		*/
491		public function getThemeDirPath(string $theme, string $dir = 'layouts'): string
492		{
493		return Util::joinFile($this->getThemesPath(), $theme, $dir);
494		}
495
496	1	/*
497		* Language helpers.
498	1	*/
499
500		/**
501	1	* Returns an array of available languages.
502		*
503		* @throws ConfigException
504		*/
505		public function getLanguages(): array
506		{
507		if ($this->languages !== null) {
508		return $this->languages;
509	1	}
510		$languages = array_filter((array) $this->get('languages'), function ($language) {
511		return !(isset($language['enabled']) && $language['enabled'] === false);
512		});
513		if (!\is_int(array_search($this->getLanguageDefault(), array_column($languages, 'code')))) {
514		throw new ConfigException(\sprintf('The default language "%s" is not listed in "languages".', $this->getLanguageDefault()));
515		}
516		$this->languages = $languages;
517	1
518		return $this->languages;
519	1	}
520
521	1	/**
522		* Returns the default language code (ie: "en", "fr-FR", etc.).
523		*
524		* @throws ConfigException
525	1	*/
526		public function getLanguageDefault(): string
527		{
528		if (!$this->get('language')) {
529		throw new ConfigException('There is no default "language" key.');
530		}
531		if (\is_array($this->get('language'))) {
532		if (!$this->get('language.code')) {
533	1	throw new ConfigException('There is no "language.code" key.');
534		}
535	1
536		return $this->get('language.code');
537	1	}
538
539	1	return $this->get('language');
540		}
541
542		/**
543	1	* Returns a language code index.
544		*
545		* @throws ConfigException
546		*/
547		public function getLanguageIndex(string $code): int
548		{
549		$array = array_column($this->getLanguages(), 'code');
550		if (false === $index = array_search($code, $array)) {
551		throw new ConfigException(\sprintf('The language code "%s" is not defined.', $code));
552		}
553
554	1	return $index;
555		}
556	1
557	1	/**
558		* Returns the property value of a (specified or the default) language.
559		*
560		* @throws ConfigException
561	1	*/
562		public function getLanguageProperty(string $property, ?string $code = null): string
563		{
564		$code = $code ?? $this->getLanguageDefault();
565		$properties = array_column($this->getLanguages(), $property, 'code');
566		if (empty($properties)) {
567	1	throw new ConfigException(\sprintf('Property "%s" is not defined for language "%s".', $property, $code));
568		}
569	1
570	1	return $properties[$code];
571	1	}
572
573		/*
574		* Cache helpers.
575		*/
576
577		/**
578		* Is cache dir is absolute to system files
579		* or relative to project destination?
580		*/
581		public function isCacheDirIsAbsolute(): bool
582		{
583	1	$path = (string) $this->get('cache.dir');
584		if (Util::joinFile($path) == realpath(Util::joinFile($path))) {
585	1	return true;
586		}
587	1
588	1	return false;
589		}
590
591	1	/*
592		* Private functions.
593		*/
594
595		/**
596		* Set configuration from environment variables starting with "CECIL_".
597		*/
598		private function setFromEnv(): void
599	1	{
600		foreach (getenv() as $key => $value) {
601		if (str_starts_with($key, 'CECIL_')) {
602	1	$this->data->set(str_replace(['cecil_', '_'], ['', '.'], strtolower($key)), $this->castSetValue($value));
603		}
604		}
605		}
606	1
607	1	/**
608		* Casts boolean value given to set() as string.
609		*
610	1	* @param mixed $value
611		*
612		* @return bool\|mixed
613		*/
614		private function castSetValue($value)
615		{
616	1	$filteredValue = filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);
617	1
618	1	if ($filteredValue !== null) {
619	1	return $filteredValue;
620	1	}
621	1
622	1	return $value;
623	1	}
624	1
625	1	/**
626	1	* Validate the configuration.
627	1	*
628		* @throws ConfigException
629		*/
630		private function validate(): void
631		{
632		// default language must be valid
633		if (!preg_match('/^' . Config::LANG_CODE_PATTERN . '$/', $this->getLanguageDefault())) {
634		throw new ConfigException(\sprintf('Default language code "%s" is not valid (e.g.: "language: fr-FR").', $this->getLanguageDefault()));
635		}
636		// if language is set then the locale is required and must be valid
637	1	foreach ((array) $this->get('languages') as $lang) {
638		if (!isset($lang['locale'])) {
639		throw new ConfigException('A language locale is not defined.');
640		}
641		if (!preg_match('/^' . Config::LANG_LOCALE_PATTERN . '$/', $lang['locale'])) {
642		throw new ConfigException(\sprintf('The language locale "%s" is not valid (e.g.: "locale: fr_FR").', $lang['locale']));
643		}
644		}
645
646		// check for deprecated options
647		$deprecatedConfigFile = Util\File::getRealPath('../config/deprecated.php');
648		$deprecatedConfig = require $deprecatedConfigFile;
649		array_walk($deprecatedConfig, function ($to, $from) {
650		if ($this->has($from)) {
651		if (empty($to)) {
652		throw new ConfigException("Option `$from` is deprecated and must be removed.");
653		}
654		$path = explode(':', $to);
655		$step = 0;
656		$formatedPath = '';
657		foreach ($path as $fragment) {
658		$step = $step + 2;
659		$formatedPath .= "$fragment:\n" . str_pad(' ', $step);
660		}
661		throw new ConfigException("Option `$from` must be moved to:\n```\n$formatedPath\n```");
662		}
663		});
664		}
665		}
666

Cecilapp / Cecil

Pull Request — master (#2148)

Config::isEnabled() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like