Aura\Router\RouterContainer

Complexity

Total Complexity

23

Size/Duplication

Total Lines	344
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	13

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	loggerFactory()	0	4	1
A	routeFactory()	0	4	1
A	mapFactory()	0	4	1
A	buildMap()	0	4	1
A	setLoggerFactory()	0	4	1
A	setRouteFactory()	0	4	1
A	setMapFactory()	0	4	1
A	setMapBuilder()	0	4	1
A	getMatcher()	0	11	2
A	getGenerator()	0	7	2
A	getLogger()	0	7	2
A	getRoute()	0	7	2
A	getRuleIterator()	0	13	2
A	getMap()	0	8	2
A	newRouteHelper()	0	4	1
A	newRouteRawHelper()	0	4	1

<?php
/**
 *
 * This file is part of Aura for PHP.
 *
 * @license http://opensource.org/licenses/bsd-license.php BSD
 *
 */
namespace Aura\Router;

use Aura\Router\Rule;
use Psr\Log\NullLogger;

/**
 *
 * A library-specific container.
 *
 * @package Aura.Router
 *
 */
class RouterContainer
{
    /**
     *
     * Generates paths from routes.
     *
     * @var Generator
     *
     */
    protected $generator;

    /**
     *
     * Logs activity in the Matcher.
     *
     * @var Psr\Log\LoggerInterface
     *
     */
    protected $logger;

    /**
     *
     * A factory to create the logger.
     *
     * @var callable
     *
     */
    protected $loggerFactory;

    /**
     *
     * A route map.
     *
     * @var Map
     *
     */
    protected $map;

    /**
     *
     * A factory to create the map.
     *
     * @var callable
     *
     */
    protected $mapFactory;

    /**
     *
     * The route matcher.
     *
     * @var Matcher
     *
     */
    protected $matcher;

    /**
     *
     * A proto-route for the map.
     *
     * @var Route
     *
     */
    protected $route;

    /**
     *
     * A factory to create the route.
     *
     * @var callable
     *
     */
    protected $routeFactory;

    /**
     *
     * An collection of route-matching rules to iterate through.
     *
     * @var RuleIterator
     *
     */
    protected $ruleIterator;

    /**
     *
     * The basepath to use for matching and generating.
     *
     * @var string
     *
     */
    protected $basepath;

    /**
     *
     * Constructor.
     *
     * @param string $basepath The basepath to use for matching and generating.
     *
     */
    public function __construct($basepath = null)
    {
        $this->basepath = $basepath;

        $this->setLoggerFactory([$this, 'loggerFactory']);

        $this->setRouteFactory([$this, 'routeFactory']);

        $this->setMapFactory([$this, 'mapFactory']);

        $this->setMapBuilder([$this, 'buildMap']);
    }

    /**
     * Creates a Logger
     *
     * @return NullLogger
     *
     * @access protected
     */
    protected function loggerFactory()
    {
        return new NullLogger();
    }

    /**
     * Creates a new Route
     *
     * @return Route
     *
     * @access protected
     */
    protected function routeFactory()
    {
        return new Route();
    }

    /**
     * mapFactory
     *
     * @return mixed
     *
     * @access protected
     */
    protected function mapFactory()
    {
        return new Map($this->getRoute());
    }

    /**
     * Builds a map
     *
     * @param Map $map DESCRIPTION
     *
     * @return mixed
     *
     * @access protected
     */
    protected function buildMap(Map $map)

The parameter $map is not used and could be removed.

    {
        // do nothing
    }

    /**
     *
     * Sets the logger factory.
     *
     * @param callable $loggerFactory The logger factory.
     *
     * @return null
     *
     */
    public function setLoggerFactory(callable $loggerFactory)
    {
        $this->loggerFactory = $loggerFactory;
    }

    /**
     *
     * Sets the proto-route factory.
     *
     * @param callable $routeFactory The proto-route factory.
     *
     * @return null
     *
     */
    public function setRouteFactory(callable $routeFactory)
    {
        $this->routeFactory = $routeFactory;
    }

    /**
     *
     * Sets the map factory.
     *
     * @param callable $mapFactory The map factory.
     *
     * @return null
     *
     */
    public function setMapFactory(callable $mapFactory)
    {
        $this->mapFactory = $mapFactory;
    }

    /**
     *
     * Sets the map builder.
     *
     * @param callable $mapBuilder The map builder.
     *
     * @return null
     *
     */
    public function setMapBuilder(callable $mapBuilder)
    {
        $this->mapBuilder = $mapBuilder;

The property mapBuilder does not exist. Did you maybe forget to declare it?

    }

    /**
     *
     * Gets the shared Map instance. Creates it with the map factory, and runs
     * it through the map builder, on first call.
     *
     * @return Map
     *
     */
    public function getMap()
    {
        if (! $this->map) {
            $this->map = call_user_func($this->mapFactory);
            call_user_func($this->mapBuilder, $this->map);
        }
        return $this->map;
    }

    /**
     *
     * Gets the shared Matcher instance.
     *
     * @return Matcher
     *
     */
    public function getMatcher()
    {
        if (! $this->matcher) {
            $this->matcher = new Matcher(
                $this->getMap(),
                $this->getLogger(),
                $this->getRuleIterator()
            );
        }
        return $this->matcher;
    }

    /**
     *
     * Gets the shared Generator instance.
     *
     * @return Generator
     *
     */
    public function getGenerator()
    {
        if (! $this->generator) {
            $this->generator = new Generator($this->getMap(), $this->basepath);
        }
        return $this->generator;
    }

    /**
     *
     * Gets the shared Logger instance.
     *
     * @return Logger
     *
     */
    public function getLogger()
    {
        if (! $this->logger) {
            $this->logger = call_user_func($this->loggerFactory);
        }
        return $this->logger;
    }

    /**
     *
     * Gets the shared proto-route instance.
     *
     * @return Route
     *
     */
    public function getRoute()
    {
        if (! $this->route) {
            $this->route = call_user_func($this->routeFactory);
        }
        return $this->route;
    }

    /**
     *
     * Gets the rule iterator instance.
     *
     * @return RuleIterator
     *
     */
    public function getRuleIterator()
    {
        if (! $this->ruleIterator) {
            $this->ruleIterator = new Rule\RuleIterator([

It seems like new \Aura\Router\Rule\RuleIterator(array(new \Aura\Router\Rule\Secure(), new \Aura\Router\Rule\Host(), new \Aura\Router\Rule\Path($this->basepath), new \Aura\Router\Rule\Allows(), new \Aura\Router\Rule\Accepts())) of type object<Aura\Router\Rule\RuleIterator> is incompatible with the declared type object<Aura\Router\RuleIterator> of property $ruleIterator.

                new Rule\Secure(),
                new Rule\Host(),
                new Rule\Path($this->basepath),
                new Rule\Allows(),
                new Rule\Accepts(),
            ]);
        }
        return $this->ruleIterator;

The expression $this->ruleIterator; of type Aura\Router\Rule\RuleIterator|Aura\Router\RuleIterator adds the type Aura\Router\Rule\RuleIterator to the return on line 338 which is incompatible with the return type documented by Aura\Router\RouterContainer::getRuleIterator of type Aura\Router\RuleIterator.

    }

    /**
     *
     * Gets a new route generation helper
     *
     * @return Helper\Route
     *
     */
    public function newRouteHelper()
    {
        return new Helper\Route($this->getGenerator());
    }

    /**
     *
     * Gets a new raw route generation helper
     *
     * @return Helper\RouteRaw
     *
     */
    public function newRouteRawHelper()
    {
        return new Helper\RouteRaw($this->getGenerator());
    }
}