Factory::extractConditions() - Code Metrics - Inspection of "Refactor some complex parts" - captainhook-git/captainhook - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 16f015...55d18a )

by Sebastian

created 2023-11-30 21:20 UTC

Factory::extractConditions() A

↳ Parent: Factory

Complexity

Conditions	3
Paths	4

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	1
c	1
b	0
f	0
nc	4
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	3
rs	10

<?php

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

namespace CaptainHook\App\Config;

use CaptainHook\App\CH;
use CaptainHook\App\Config;
use CaptainHook\App\Hook\Util as HookUtil;
use CaptainHook\App\Storage\File\Json;
use RuntimeException;

/**
 * Class Factory
 *
 * @package CaptainHook
 * @author  Sebastian Feldmann <[email protected]>
 * @link    https://github.com/captainhookphp/captainhook
 * @since   Class available since Release 0.9.0
 * @internal
 */
final class Factory
{
    /**
     * Maximal level in including config files
     *
     * @var int
     */
    private $maxIncludeLevel = 1;

    /**
     * Current level of inclusion
     *
     * @var int
     */
    private $includeLevel = 0;

    /**
     * Create a CaptainHook configuration
     *
     * @param  string               $path     Path to the configuration file
     * @param  array<string, mixed> $settings Settings passed as options on the command line
     * @return \CaptainHook\App\Config
     * @throws \Exception
     */
    public function createConfig(string $path = '', array $settings = []): Config
    {
        $path     = $path ?: getcwd() . DIRECTORY_SEPARATOR . CH::CONFIG;
        $file     = new Json($path);
        $settings = $this->combineArgumentsAndSettingFile($file, $settings);

        return $this->setupConfig($file, $settings);
    }

    /**
     * Read settings from a local 'config' file
     *
     * If you prefer a different verbosity or use a different run mode locally then your teammates do.
     * You can create a 'captainhook.config.json' in the same directory as your captainhook
     * configuration file and use it to overwrite the 'config' settings of that configuration file.
     * Exclude the 'captainhook.config.json' from version control, and you don't have to edit the
     * version controlled configuration for your local specifics anymore.
     *
     * Settings provided as arguments still overrule config file settings:
     *
     * ARGUMENTS > SETTINGS_FILE > CONFIGURATION
     *
     * @param  \CaptainHook\App\Storage\File\Json $file
     * @param  array<string, mixed>               $settings
     * @return array<string, mixed>
     */
    private function combineArgumentsAndSettingFile(Json $file, array $settings): array
    {
        $settingsFile = new Json(dirname($file->getPath()) . '/captainhook.config.json');
        if ($settingsFile->exists()) {
            $fileSettings = $settingsFile->readAssoc();
            $settings     = array_merge($fileSettings, $settings);
        }
        return $settings;
    }

    /**
     * Includes an external captainhook configuration
     *
     * @param  string $path
     * @return \CaptainHook\App\Config
     * @throws \Exception
     */
    private function includeConfig(string $path): Config
    {
        $file = new Json($path);
        if (!$file->exists()) {
            throw new RuntimeException('Config to include not found: ' . $path);
        }
        return $this->setupConfig($file);
    }

    /**
     * Return a configuration with data loaded from json file if it exists
     *
     * @param  \CaptainHook\App\Storage\File\Json $file
     * @param  array<string, mixed>               $settings
     * @return \CaptainHook\App\Config
     * @throws \Exception
     */
    private function setupConfig(Json $file, array $settings = []): Config
    {
        return $file->exists()
            ? $this->loadConfigFromFile($file, $settings)
            : new Config($file->getPath(), false, $settings);
    }

    /**
     * Loads a given file into given the configuration
     *
     * @param  \CaptainHook\App\Storage\File\Json $file
     * @param  array<string, mixed>               $settings
     * @return \CaptainHook\App\Config
     * @throws \Exception
     */
    private function loadConfigFromFile(Json $file, array $settings): Config
    {
        $json = $file->readAssoc();
        Util::validateJsonConfiguration($json);

        $settings = Util::mergeSettings($this->extractSettings($json), $settings);
        $config   = new Config($file->getPath(), true, $settings);
        if (!empty($settings)) {
            $json['config'] = $settings;
        }

        $this->appendIncludedConfigurations($config, $json);

        foreach (HookUtil::getValidHooks() as $hook => $class) {
            if (isset($json[$hook])) {
                $this->configureHook($config->getHookConfig($hook), $json[$hook]);
            }
        }

        $this->validatePhpPath($config);
        return $config;
    }

    /**
     * Return the `config` section of some json
     *
     * @param  array<string, mixed> $json
     * @return array<string, mixed>
     */
    private function extractSettings(array $json): array
    {
        return isset($json['config']) && is_array($json['config']) ? $json['config'] : [];
    }

    /**
     * Returns the `conditions` section of an actionJson
     *
     * @param array<string, mixed> $json
     * @return array<string, mixed>
     */
    private function extractConditions(mixed $json): array
    {
        return isset($json['conditions']) && is_array($json['conditions']) ? $json['conditions'] : [];
    }

    /**
     * Returns the `options` section af some json
     *
     * @param array<string, mixed> $json
     * @return array<string, string>
     */
    private function extractOptions(mixed $json): array
    {
        return isset($json['options']) && is_array($json['options']) ? $json['options'] : [];
    }

    /**
     * Set up a hook configuration by json data
     *
     * @param  \CaptainHook\App\Config\Hook $config
     * @param  array<string, mixed>         $json
     * @return void
     * @throws \Exception
     */
    private function configureHook(Config\Hook $config, array $json): void
    {
        $config->setEnabled($json['enabled']);
        foreach ($json['actions'] as $actionJson) {
            $options    = $this->extractOptions($actionJson);
            $conditions = $this->extractConditions($actionJson);
            $settings   = $this->extractSettings($actionJson);
            $config->addAction(new Config\Action($actionJson['action'], $options, $conditions, $settings));
        }
    }

    /**
     * Makes sure the configured PHP executable exists
     *
     * @param  \CaptainHook\App\Config $config
     * @return void
     */
    private function validatePhpPath(Config $config): void
    {
        if (empty($config->getPhpPath())) {
            return;
        }
        $foundPHP    = false;
        $pathToCheck = [$config->getPhpPath()];
        $parts       = explode(' ', $config->getPhpPath());
        // if there are spaces in the php-path and they are not escaped
        // it looks like an executable is used to find the PHP binary
        // so at least check if the executable exists
        if (count($parts) > 1 && substr($parts[0], -1) !== '\\') {
            $pathToCheck[] = $parts[0];
        }

        foreach ($pathToCheck as $path) {
            if (file_exists($path)) {
                $foundPHP = true;
                break;
            }
        }

        if (!$foundPHP) {
            throw new RuntimeException('The configured php-path is wrong: ' . $config->getPhpPath());
        }
    }

    /**
     * Append all included configuration to the current configuration
     *
     * @param  \CaptainHook\App\Config $config
     * @param  array<string, mixed>    $json
     * @throws \Exception
     */
    private function appendIncludedConfigurations(Config $config, array $json): void
    {
        $this->readMaxIncludeLevel($json);

        if ($this->includeLevel < $this->maxIncludeLevel) {
            $this->includeLevel++;
            $includes = $this->loadIncludedConfigs($json, $config->getPath());
            foreach (HookUtil::getValidHooks() as $hook => $class) {
                $this->mergeHookConfigFromIncludes($config->getHookConfig($hook), $includes);
            }
            $this->includeLevel--;
        }
    }

    /**
     * Check config section for 'includes-level' setting
     *
     * @param array<string, mixed> $json
     */
    private function readMaxIncludeLevel(array $json): void
    {
        // read the include-level setting only for the actual configuration
        if ($this->includeLevel === 0 && isset($json['config'][Config::SETTING_INCLUDES_LEVEL])) {
            $this->maxIncludeLevel = (int) $json['config'][Config::SETTING_INCLUDES_LEVEL];
        }
    }

    /**
     * Merge a given hook config with the corresponding hook configs from a list of included configurations
     *
     * @param  \CaptainHook\App\Config\Hook $hook
     * @param  \CaptainHook\App\Config[]    $includes
     * @return void
     */
    private function mergeHookConfigFromIncludes(Hook $hook, array $includes): void
    {
        foreach ($includes as $includedConfig) {
            $includedHook = $includedConfig->getHookConfig($hook->getName());
            if ($includedHook->isEnabled()) {
                $hook->setEnabled(true);
                // This `setEnable` is solely to overwrite the main configuration in the special case that the hook
                // is not configured at all. In this case the empty config is disabled by default, and adding an
                // empty hook config just to enable the included actions feels a bit dull.
                // Since the main hook is processed last (if one is configured) the enabled flag will be overwritten
                // once again by the main config value. This is to make sure that if somebody disables a hook in its
                // main configuration no actions will get executed, even if we have enabled hooks in any include file.
                $this->copyActionsFromTo($includedHook, $hook);
            }
        }
    }

    /**
     * Return list of included configurations to add them to the main configuration afterwards
     *
     * @param  array<string, mixed> $json
     * @param  string               $path
     * @return \CaptainHook\App\Config[]
     * @throws \Exception
     */
    protected function loadIncludedConfigs(array $json, string $path): array
    {
        $includes  = [];
        $directory = dirname($path);
        $files     = isset($json['config'][Config::SETTING_INCLUDES])
                     && is_array($json['config'][Config::SETTING_INCLUDES])
                   ? $json['config'][Config::SETTING_INCLUDES]
                   : [];

        foreach ($files as $file) {
            $includes[] = $this->includeConfig($directory . DIRECTORY_SEPARATOR . $file);
        }
        return $includes;
    }

    /**
     * Copy action from a given configuration to the second given configuration
     *
     * @param \CaptainHook\App\Config\Hook $sourceConfig
     * @param \CaptainHook\App\Config\Hook $targetConfig
     */
    private function copyActionsFromTo(Hook $sourceConfig, Hook $targetConfig): void
    {
        foreach ($sourceConfig->getActions() as $action) {
            $targetConfig->addAction($action);
        }
    }

    /**
     * Config factory method
     *
     * @param  string               $path
     * @param  array<string, mixed> $settings
     * @return \CaptainHook\App\Config
     * @throws \Exception
     */
    public static function create(string $path = '', array $settings = []): Config
    {
        $factory = new static();
        return $factory->createConfig($path, $settings);
    }
}


1		<?php
2
3		/**
4		* This file is part of CaptainHook
5		*
6		* (c) Sebastian Feldmann <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace CaptainHook\App\Config;
13
14		use CaptainHook\App\CH;
15		use CaptainHook\App\Config;
16		use CaptainHook\App\Hook\Util as HookUtil;
17		use CaptainHook\App\Storage\File\Json;
18		use RuntimeException;
19
20		/**
21		* Class Factory
22		*
23		* @package CaptainHook
24		* @author Sebastian Feldmann <[email protected]>
25		* @link https://github.com/captainhookphp/captainhook
26		* @since Class available since Release 0.9.0
27		* @internal
28		*/
29		final class Factory
30		{
31		/**
32		* Maximal level in including config files
33		*
34		* @var int
35		*/
36		private $maxIncludeLevel = 1;
37
38		/**
39		* Current level of inclusion
40		*
41		* @var int
42		*/
43		private $includeLevel = 0;
44
45		/**
46		* Create a CaptainHook configuration
47		*
48		* @param string $path Path to the configuration file
49		* @param array<string, mixed> $settings Settings passed as options on the command line
50		* @return \CaptainHook\App\Config
51		* @throws \Exception
52		*/
53	56	public function createConfig(string $path = '', array $settings = []): Config
54		{
55	56	$path = $path ?: getcwd() . DIRECTORY_SEPARATOR . CH::CONFIG;
56	56	$file = new Json($path);
57	56	$settings = $this->combineArgumentsAndSettingFile($file, $settings);
58
59	56	return $this->setupConfig($file, $settings);
60		}
61
62		/**
63		* Read settings from a local 'config' file
64		*
65		* If you prefer a different verbosity or use a different run mode locally then your teammates do.
66		* You can create a 'captainhook.config.json' in the same directory as your captainhook
67		* configuration file and use it to overwrite the 'config' settings of that configuration file.
68		* Exclude the 'captainhook.config.json' from version control, and you don't have to edit the
69		* version controlled configuration for your local specifics anymore.
70		*
71		* Settings provided as arguments still overrule config file settings:
72		*
73		* ARGUMENTS > SETTINGS_FILE > CONFIGURATION
74		*
75		* @param \CaptainHook\App\Storage\File\Json $file
76		* @param array<string, mixed> $settings
77		* @return array<string, mixed>
78		*/
79	56	private function combineArgumentsAndSettingFile(Json $file, array $settings): array
80		{
81	56	$settingsFile = new Json(dirname($file->getPath()) . '/captainhook.config.json');
82	56	if ($settingsFile->exists()) {
83	1	$fileSettings = $settingsFile->readAssoc();
84	1	$settings = array_merge($fileSettings, $settings);
85		}
86	56	return $settings;
87		}
88
89		/**
90		* Includes an external captainhook configuration
91		*
92		* @param string $path
93		* @return \CaptainHook\App\Config
94		* @throws \Exception
95		*/
96	7	private function includeConfig(string $path): Config
97		{
98	7	$file = new Json($path);
99	7	if (!$file->exists()) {
100	1	throw new RuntimeException('Config to include not found: ' . $path);
101		}
102	6	return $this->setupConfig($file);
103		}
104
105		/**
106		* Return a configuration with data loaded from json file if it exists
107		*
108		* @param \CaptainHook\App\Storage\File\Json $file
109		* @param array<string, mixed> $settings
110		* @return \CaptainHook\App\Config
111		* @throws \Exception
112		*/
113	56	private function setupConfig(Json $file, array $settings = []): Config
114		{
115	56	return $file->exists()
116	50	? $this->loadConfigFromFile($file, $settings)
117	54	: new Config($file->getPath(), false, $settings);
118		}
119
120		/**
121		* Loads a given file into given the configuration
122		*
123		* @param \CaptainHook\App\Storage\File\Json $file
124		* @param array<string, mixed> $settings
125		* @return \CaptainHook\App\Config
126		* @throws \Exception
127		*/
128	50	private function loadConfigFromFile(Json $file, array $settings): Config
129		{
130	50	$json = $file->readAssoc();
131	50	Util::validateJsonConfiguration($json);
132
133	50	$settings = Util::mergeSettings($this->extractSettings($json), $settings);
134	50	$config = new Config($file->getPath(), true, $settings);
135	50	if (!empty($settings)) {
136	42	$json['config'] = $settings;
137		}
138
139	50	$this->appendIncludedConfigurations($config, $json);
140
141	49	foreach (HookUtil::getValidHooks() as $hook => $class) {
142	49	if (isset($json[$hook])) {
143	49	$this->configureHook($config->getHookConfig($hook), $json[$hook]);
144		}
145		}
146
147	49	$this->validatePhpPath($config);
148	48	return $config;
149		}
150
151		/**
152		* Return the `config` section of some json
153		*
154		* @param array<string, mixed> $json
155		* @return array<string, mixed>
156		*/
157	50	private function extractSettings(array $json): array
158		{
159	50	return isset($json['config']) && is_array($json['config']) ? $json['config'] : [];
160		}
161
162		/**
163		* Returns the `conditions` section of an actionJson
164		*
165		* @param array<string, mixed> $json
166		* @return array<string, mixed>
167		*/
168	42	private function extractConditions(mixed $json): array
169		{
170	42	return isset($json['conditions']) && is_array($json['conditions']) ? $json['conditions'] : [];
171		}
172
173		/**
174		* Returns the `options` section af some json
175		*
176		* @param array<string, mixed> $json
177		* @return array<string, string>
178		*/
179	42	private function extractOptions(mixed $json): array
180		{
181	42	return isset($json['options']) && is_array($json['options']) ? $json['options'] : [];
182		}
183
184		/**
185		* Set up a hook configuration by json data
186		*
187		* @param \CaptainHook\App\Config\Hook $config
188		* @param array<string, mixed> $json
189		* @return void
190		* @throws \Exception
191		*/
192	49	private function configureHook(Config\Hook $config, array $json): void
193		{
194	49	$config->setEnabled($json['enabled']);
195	49	foreach ($json['actions'] as $actionJson) {
196	42	$options = $this->extractOptions($actionJson);
197	42	$conditions = $this->extractConditions($actionJson);
198	42	$settings = $this->extractSettings($actionJson);
199	42	$config->addAction(new Config\Action($actionJson['action'], $options, $conditions, $settings));
200		}
201		}
202
203		/**
204		* Makes sure the configured PHP executable exists
205		*
206		* @param \CaptainHook\App\Config $config
207		* @return void
208		*/
209	49	private function validatePhpPath(Config $config): void
210		{
211	49	if (empty($config->getPhpPath())) {
212	47	return;
213		}
214	2	$foundPHP = false;
215	2	$pathToCheck = [$config->getPhpPath()];
216	2	$parts = explode(' ', $config->getPhpPath());
217		// if there are spaces in the php-path and they are not escaped
218		// it looks like an executable is used to find the PHP binary
219		// so at least check if the executable exists
220	2	if (count($parts) > 1 && substr($parts[0], -1) !== '\\') {
221	1	$pathToCheck[] = $parts[0];
222		}
223
224	2	foreach ($pathToCheck as $path) {
225	2	if (file_exists($path)) {
226	1	$foundPHP = true;
227	1	break;
228		}
229		}
230
231	2	if (!$foundPHP) {
232	1	throw new RuntimeException('The configured php-path is wrong: ' . $config->getPhpPath());
233		}
234		}
235
236		/**
237		* Append all included configuration to the current configuration
238		*
239		* @param \CaptainHook\App\Config $config
240		* @param array<string, mixed> $json
241		* @throws \Exception
242		*/
243	50	private function appendIncludedConfigurations(Config $config, array $json): void
244		{
245	50	$this->readMaxIncludeLevel($json);
246
247	50	if ($this->includeLevel < $this->maxIncludeLevel) {
248	50	$this->includeLevel++;
249	50	$includes = $this->loadIncludedConfigs($json, $config->getPath());
250	49	foreach (HookUtil::getValidHooks() as $hook => $class) {
251	49	$this->mergeHookConfigFromIncludes($config->getHookConfig($hook), $includes);
252		}
253	49	$this->includeLevel--;
254		}
255		}
256
257		/**
258		* Check config section for 'includes-level' setting
259		*
260		* @param array<string, mixed> $json
261		*/
262	50	private function readMaxIncludeLevel(array $json): void
263		{
264		// read the include-level setting only for the actual configuration
265	50	if ($this->includeLevel === 0 && isset($json['config'][Config::SETTING_INCLUDES_LEVEL])) {
266	2	$this->maxIncludeLevel = (int) $json['config'][Config::SETTING_INCLUDES_LEVEL];
267		}
268		}
269
270		/**
271		* Merge a given hook config with the corresponding hook configs from a list of included configurations
272		*
273		* @param \CaptainHook\App\Config\Hook $hook
274		* @param \CaptainHook\App\Config[] $includes
275		* @return void
276		*/
277	49	private function mergeHookConfigFromIncludes(Hook $hook, array $includes): void
278		{
279	49	foreach ($includes as $includedConfig) {
280	6	$includedHook = $includedConfig->getHookConfig($hook->getName());
281	6	if ($includedHook->isEnabled()) {
282	6	$hook->setEnabled(true);
283		// This `setEnable` is solely to overwrite the main configuration in the special case that the hook
284		// is not configured at all. In this case the empty config is disabled by default, and adding an
285		// empty hook config just to enable the included actions feels a bit dull.
286		// Since the main hook is processed last (if one is configured) the enabled flag will be overwritten
287		// once again by the main config value. This is to make sure that if somebody disables a hook in its
288		// main configuration no actions will get executed, even if we have enabled hooks in any include file.
289	6	$this->copyActionsFromTo($includedHook, $hook);
290		}
291		}
292		}
293
294		/**
295		* Return list of included configurations to add them to the main configuration afterwards
296		*
297		* @param array<string, mixed> $json
298		* @param string $path
299		* @return \CaptainHook\App\Config[]
300		* @throws \Exception
301		*/
302	50	protected function loadIncludedConfigs(array $json, string $path): array
303		{
304	50	$includes = [];
305	50	$directory = dirname($path);
306	50	$files = isset($json['config'][Config::SETTING_INCLUDES])
307	50	&& is_array($json['config'][Config::SETTING_INCLUDES])
308	7	? $json['config'][Config::SETTING_INCLUDES]
309	43	: [];
310
311	50	foreach ($files as $file) {
312	7	$includes[] = $this->includeConfig($directory . DIRECTORY_SEPARATOR . $file);
313		}
314	49	return $includes;
315		}
316
317		/**
318		* Copy action from a given configuration to the second given configuration
319		*
320		* @param \CaptainHook\App\Config\Hook $sourceConfig
321		* @param \CaptainHook\App\Config\Hook $targetConfig
322		*/
323	6	private function copyActionsFromTo(Hook $sourceConfig, Hook $targetConfig): void
324		{
325	6	foreach ($sourceConfig->getActions() as $action) {
326	6	$targetConfig->addAction($action);
327		}
328		}
329
330		/**
331		* Config factory method
332		*
333		* @param string $path
334		* @param array<string, mixed> $settings
335		* @return \CaptainHook\App\Config
336		* @throws \Exception
337		*/
338	56	public static function create(string $path = '', array $settings = []): Config
339		{
340	56	$factory = new static();
341	56	return $factory->createConfig($path, $settings);
342		}
343		}
344

captainhook-git / captainhook

Push — main ( 16f015...55d18a )

Factory::extractConditions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like