Bankiru\Api\Rpc\Routing\Router

Complexity

Total Complexity

20

Size/Duplication

Total Lines	198
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

70.83%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getMethodCollection()	0	8	2
A	match()	0	4	1
A	setOption()	0	6	1
A	getOption()	0	8	2
B	setOptions()	0	24	4
B	getMatcher()	0	35	4
A	getConfigCacheFactory()	0	8	2
A	validateOption()	0	6	2
A	warmUp()	0	10	1

<?php

namespace Bankiru\Api\Rpc\Routing;

use Symfony\Component\Config\ConfigCacheFactory;
use Symfony\Component\Config\ConfigCacheFactoryInterface;
use Symfony\Component\Config\ConfigCacheInterface;
use Symfony\Component\Config\Resource\FileResource;
use Symfony\Component\HttpKernel\CacheWarmer\WarmableInterface;

final class Router implements MethodMatcher, WarmableInterface
{
    /** @var MethodCollectionLoader */
    private $loader;
    /** @var MethodCollection */
    private $collection;
    /** @var MethodMatcher */
    private $matcher;
    /**
     * @var string
     */
    private $name;
    /** @var ConfigCacheFactoryInterface */
    private $configCacheFactory;
    private $options = [];

    /**
     * Router constructor.
     *
     * @param MethodCollectionLoader $loader
     * @param string                 $name
     * @param array                  $options
     */
    public function __construct(MethodCollectionLoader $loader, $name, array $options = [])
    {
        $this->loader = $loader;
        $this->name   = $name;
        $this->setOptions($options);
    }

    /**
     * @return MethodCollection
     */
    public function getMethodCollection()
    {
        if (null === $this->collection) {
            $this->collection = $this->loader->loadCollection();
        }

        return $this->collection;
    }

    /** {@inheritdoc} */
    public function match($method)
    {
        return $this->getMatcher()->match($method);
    }

    /**
     * Warms up the cache.
     *
     * @param string $cacheDir The cache directory
     */
    public function warmUp($cacheDir)
    {
        $currentDir = $this->getOption('cache_dir');

        // force cache generation
        $this->setOption('cache_dir', $cacheDir);

        $this->getMatcher();
        $this->setOption('cache_dir', $currentDir);
    }

    /**
     * Sets an option.
     *
     * @param string $key   The key
     * @param mixed  $value The value
     *
     * @throws \InvalidArgumentException
     */
    public function setOption($key, $value)
    {
        $this->validateOption($key);

        $this->options[$key] = $value;
    }

    /**
     * Gets an option value.
     *
     * @param string $key The key
     *
     * @return mixed The value
     *
     * @throws \InvalidArgumentException
     */
    public function getOption($key)
    {
        if (!array_key_exists($key, $this->options)) {
            throw new \InvalidArgumentException(sprintf('The Router does not support the "%s" option.', $key));
        }

        return $this->options[$key];
    }

    /**
     * Sets options.
     *
     * Available options:
     *
     *   * cache_dir:              The cache directory (or null to disable caching)
     *   * debug:                  Whether to enable debugging or not (false by default)
     *
     * @param array $options An array of options
     *
     * @throws \InvalidArgumentException When unsupported option is provided
     */
    public function setOptions(array $options)
    {
        $this->options = [
            'cache_dir'           => null,
            'debug'               => false,
            'matcher_cache_class' => ucfirst($this->name) . 'MethodMatcher',
        ];

        // check option names and live merge, if errors are encountered Exception will be thrown
        $invalid = [];
        foreach ($options as $key => $value) {
            if (array_key_exists($key, $this->options)) {
                $this->options[$key] = $value;
            } else {
                $invalid[] = $key;
            }
        }

        if (!empty($invalid)) {
            throw new \InvalidArgumentException(
                sprintf('The Router does not support the following options: "%s".', implode('", "', $invalid))
            );
        }
    }

    /**
     * @return MethodMatcher
     */
    private function getMatcher()
    {
        if (null !== $this->matcher) {
            return $this->matcher;
        }

        if (null === $this->options['cache_dir'] || null === $this->options['matcher_cache_class']) {
            $this->matcher = new CollectionMatcher($this->getMethodCollection());

            return $this->matcher;
        }

        $cache = $this->getConfigCacheFactory()->cache(
            $this->options['cache_dir'] . '/rpc/' . $this->options['matcher_cache_class'] . '.php',
            function (ConfigCacheInterface $cache) {
                $dumper = new MatcherDumper();

                $options = [
                    'class' => $this->options['matcher_cache_class'],
                ];

                $resources   = $this->getMethodCollection()->getResources();
                $refl        = new \ReflectionClass(MatcherDumper::class);
                $resources[] = new FileResource($refl->getFileName());

                $cache->write($dumper->dump($this->getMethodCollection(), $options), $resources);
            }
        );

        require_once $cache->getPath();

        $this->matcher = new $this->options['matcher_cache_class']($cache);

        return $this->matcher;
    }

    /**
     * Provides the ConfigCache factory implementation, falling back to a
     * default implementation if necessary.
     *
     * @return ConfigCacheFactoryInterface $configCacheFactory
     */
    private function getConfigCacheFactory()
    {
        if (null === $this->configCacheFactory) {
            $this->configCacheFactory = new ConfigCacheFactory(true);
        }

        return $this->configCacheFactory;
    }

    /**
     * @param $key
     */
    private function validateOption($key)
    {
        if (!array_key_exists($key, $this->options)) {
            throw new \InvalidArgumentException(sprintf('The Router does not support the "%s" option.', $key));
        }
    }
}