TomPHP\ConfigServiceProvider\ApplicationConfig

Complexity

Total Complexity

17

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	2
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
B	fromFiles()	0	28	2
A	__construct()	0	5	1
A	getIterator()	0	4	1
A	getKeys()	0	4	1
A	offsetExists()	0	10	2
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	asArray()	0	4	1
A	getSeparator()	0	4	1
A	getPath()	0	4	1
A	traverseConfig()	0	14	4

<?php

namespace TomPHP\ConfigServiceProvider;

use ArrayAccess;
use IteratorAggregate;
use TomPHP\ConfigServiceProvider\Exception\EntryDoesNotExistException;
use TomPHP\ConfigServiceProvider\Exception\NoMatchingFilesException;
use TomPHP\ConfigServiceProvider\Exception\ReadOnlyException;

final class ApplicationConfig implements ArrayAccess, IteratorAggregate
{
    /**
     * @var array
     */
    private $config;

    /**
     * @var string
     */
    private $separator;

    /**
     * @api
     *
     * @param array  $patterns
     * @param string $separator
     *
     * @return ApplicationConfig
     */
    public static function fromFiles(array $patterns, $separator = '.')
    {
        $locator = new FileLocator();
        $files   = $locator->locate($patterns);

        if (empty($files)) {
            throw new NoMatchingFilesException(
                'No files found matching patterns: ' . implode(', ', $patterns)
            );
        }

        $factory = new ReaderFactory([
            '.json' => 'TomPHP\ConfigServiceProvider\JSONFileReader',
            '.php'  => 'TomPHP\ConfigServiceProvider\PHPFileReader',
        ]);

        $configs = array_map(
            function ($filename) use ($factory) {
                $reader = $factory->create($filename);
                return $reader->read($filename);
            },
            $files
        );

        $config = call_user_func_array('array_replace_recursive', $configs);

        return new self($config, $separator);
    }

    /**
     * @api
     *
     * @param array  $config
     * @param string $separator
     */
    public function __construct(array $config, $separator = '.')
    {
        $this->config    = $config;
        $this->separator = $separator;
    }

    public function getIterator()
    {
        return new ApplicationConfigIterator($this);
    }

    /**
     * @return array

Consider making the return type a bit more specific; maybe use array<integer|string>.

     */
    public function getKeys()
    {
        return array_keys(iterator_to_array(new ApplicationConfigIterator($this)));
    }

    public function offsetExists($offset)
    {
        try {
            $this->traverseConfig($this->getPath($offset));
        } catch (EntryDoesNotExistException $e) {
            return false;
        }

        return true;
    }

    public function offsetGet($offset)
    {
        return $this->traverseConfig($this->getPath($offset));
    }

    public function offsetSet($offset, $value)
    {
        throw new ReadOnlyException('Config is read only.');
    }

    public function offsetUnset($offset)
    {
        throw new ReadOnlyException('Config is read only.');
    }

    /**
     * @return array
     */
    public function asArray()
    {
        return $this->config;
    }

    /**
     * @return string
     */
    public function getSeparator()
    {
        return $this->separator;
    }

    private function getPath($offset)
    {
        return explode($this->separator, $offset);
    }

    private function traverseConfig(array $path)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $pointer = &$this->config;

        foreach ($path as $node) {
            if (!is_array($pointer) || !array_key_exists($node, $pointer)) {
                throw new EntryDoesNotExistException("No entry found for " . implode($this->separator, $path));

The string literal No entry found for does not require double quotes, as per coding-style, please use single quotes.

            }

            $pointer = &$pointer[$node];
        }

        return $pointer;
    }
}