Borobudur\Kernel\ResourceBuilder

Complexity

Total Complexity

27

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	3
A	normalize()	0	11	3
A	mergeImported()	0	11	3
A	merge()	0	10	2
A	computeMergedValue()	0	8	4
B	process()	0	20	5
A	loadResources()	0	11	3
A	getResourceFile()	0	11	2
A	getBundlePath()	0	12	2

<?php
/*
 * This file is part of the Borobudur-Kernel package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Kernel;

use Borobudur\Config\FileLoader\FileLoaderInterface;
use Borobudur\Config\FileLoader\FileLocator;
use Borobudur\DependencyInjection\ContainerBuilder;
use Borobudur\DependencyInjection\ParameterBag\Resolver;
use Borobudur\Kernel\Bundling\BundleInterface;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/16/15
 */
class ResourceBuilder
{
    /**
     * @var Resolver
     */
    private $resolver;

    /**
     * @var array
     */
    private $bundlesPath = array();

    /**
     * Constructor.
     *
     * @param ContainerBuilder $container
     * @param array            $bundles
     */
    public function __construct(ContainerBuilder $container, array $bundles)
    {
        $this->resolver = $container->getParameterBag()->getResolver();

        foreach ($bundles as $bundle) {
            if ($bundle instanceof BundleInterface) {
                $this->bundlesPath['@' . $bundle->getName()] = $bundle->getPath();
            }
        }
    }

    /**
     * Normalize array configs.
     *
     * @param array $configs
     *
     * @return array
     */
    private static function normalize(array $configs)
    {
        $normalized = array();

        if (isset($configs['imports']) && is_array($configs['imports'])) {
            $normalized = self::mergeImported($configs);
            unset($configs['imports']);
        }

        return self::merge($normalized, $configs);
    }

    /**
     * Merge imported resources.
     *
     * @param array $configs
     *
     * @return array
     */
    private static function mergeImported(array $configs)
    {
        $normalized = array();
        foreach ($configs['imports'] as $config) {
            if (is_array($config)) {
                $normalized = self::merge($normalized, $config);
            }
        }

        return $normalized;
    }

    /**
     * Merge distinct between two array recursively.
     *
     * @param array $array1
     * @param array $array2
     *
     * @return array
     */
    private static function merge(array $array1, array $array2)
    {
        $merged = $array1;

        foreach ($array2 as $key => $value) {
            $merged[$key] = self::computeMergedValue($merged, $key, $value);
        }

        return $merged;
    }

    /**
     * Compute merged value.
     *
     * @param array      $merged
     * @param string|int $key
     * @param mixed      $value
     *
     * @return array
     */
    private static function computeMergedValue(array $merged, $key, $value)
    {
        if (is_array($value) && isset ($merged[$key]) && is_array($merged[$key])) {
            return self::merge($merged[$key], $value);
        }

        return $value;
    }

    /**
     * @param FileLoaderInterface $loader
     * @param array               $configs
     *
     * @return array
     */
    public function process(FileLoaderInterface $loader, array $configs)
    {
        foreach ($configs as $name => $config) {
            if ('imports' === $name) {
                $configs[$name] = $this->process($loader, $config);
                continue;
            }

            if (null !== $resource = $this->loadResources($loader, $config)) {
                $configs[$name] = array_merge($resource, $config);
                continue;
            }

            if (is_array($config)) {
                $configs[$name] = $this->process($loader, $config);
            }
        }

        return self::normalize($configs);
    }

    /**
     * Import resource.
     *
     * @param FileLoaderInterface $loader
     * @param mixed               $config
     *
     * @return array|null
     */
    private function loadResources(FileLoaderInterface $loader, &$config)
    {
        if (isset($config['resource']) && null !== $file = $this->getResourceFile($config['resource'])) {
            $resource = $this->process($loader, $loader->import(new FileLocator($file)));
            unset($config['resource']);

            return $resource;
        }

        return null;
    }

    /**
     * Get resource file.
     *
     * @param string $resource
     *
     * @return string
     */
    private function getResourceFile($resource)
    {
        $resource = $this->resolver->resolveString($resource);
        $resource = $this->getBundlePath($resource);

        if (file_exists($resource)) {
            return $resource;
        }

        return null;
    }

    /**
     * Get bundle path resource.
     *
     * @param string $resource
     *
     * @return string
     */
    private function getBundlePath($resource)
    {
        $parts = explode('/', $resource);

        if (isset($this->bundlesPath[$parts[0]])) {
            $parts[0] = $this->bundlesPath[$parts[0]];

            return implode('/', $parts);
        }

        return $resource;
    }
}