App\Common\Config\PHPConfigLoader

Complexity

Total Complexity

11

Size/Duplication

Total Lines	94
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	importAll()	0	42	6
A	load()	0	5	1
A	supports()	0	20	4

<?php

namespace App\Common\Config;

use Symfony\Component\Config\Loader\FileLoader;
use Symfony\Component\Config\Exception\FileLoaderLoadException;
use Symfony\Component\Config\Definition\Processor;

/**
 * Class PHPConfigLoader
 *
 * @package App\Common\Config
 */
class PHPConfigLoader extends FileLoader
{
    /**
     * @var FileLocator
     */
    protected $locator;

    /**
     * Import all loadable resources
     *
     * @return array
     * @throws FileLoaderLoadException
     */
    public function importAll()
    {
        // in order to import all we need to have locator to locate these "all"
        // locator need
        if (empty($this->locator)) {
            throw new FileLoaderLoadException('importAll()');
        }

        // locator must be capable of locating all
        if (!is_callable([$this->locator, 'locateAll'])) {
            throw new FileLoaderLoadException('locateAll()');
        }

        // build list of 'all' files
        $files = $this->locator->locateAll();

        // and now try to import configuration from this list of 'all' files
        $res = [];
        foreach ($files as $file) {
            if ($this->supports($file)) {
                // file is supported - load/import it
                $config = $this->load($file);

                if (!empty($config['definition'])) {
                    // loaded config can be verified
                    $processor = new Processor();
                    $configDefinition = new $config['definition']();
                    // process config according to specified definition
                    $config = $processor->processConfiguration(
                        $configDefinition,
                        [$config]
                    );
                }

                // combine all configs into one "unified general config"
                $res = array_merge($res, $config);
            }
        }

        // array of configuration
        return $res;
    }

    /**
     * @inheritdoc
     * @return array|\StdClass loaded object
     */
    public function load($resource, $type = null)
    {
        // for PHP file load process is quite simple - just return config file content
        return require_once $resource;
    }

    /**
     * Returns whether current loader supports specified resource load
     *
     * @param mixed $resource path to config file
     * @param null $type unsused
     * @return bool
     */
    public function supports($resource, $type = null)
    {
        // $resource is expected to be path to config file
        if (!is_string($resource)) {
            return false;
        }

        // specified config file should be readable
        if (!@is_file($resource) || !@is_readable($resource)) {
            return false;
        }

        // simple check - PHP loader accepts PHP files, thus let's check file extension to be 'php'

        // fetch config file extension
        $extension = pathinfo($resource, PATHINFO_EXTENSION);

        // PHP loader accepts PHP files
        return  $extension == 'php';
    }
}