Tadcka\Component\Routing\Manager\InMemoryRouteManager

Complexity

Total Complexity

36

Size/Duplication

Total Lines	206
Duplicated Lines	20.87 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

6.74%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	findAllNameAndPattern()	0	4	1
A	findByName()	0	8	2
A	findVisibleByName()	0	10	3
A	findByNames()	0	13	3
A	findVisibleByNames()	13	13	4
A	findByRoutePattern()	0	10	3
A	findByRoutePatterns()	15	15	4
B	findVisibleByRoutePatterns()	15	15	5
A	all()	0	11	3
A	add()	0	9	2
A	remove()	0	7	2
A	save()	0	4	1
A	clear()	0	5	1
A	getClass()	0	4	1

<?php

/*
 * This file is part of the Tadcka package.
 *
 * (c) Tadas Gliaubicas <tadcka89@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tadcka\Component\Routing\Manager;

use Tadcka\Component\Routing\Exception\RoutingRuntimeException;
use Tadcka\Component\Routing\Model\Manager\RouteManager;
use Tadcka\Component\Routing\Model\Manager\RouteManagerInterface;
use Tadcka\Component\Routing\Model\RouteInterface;

/**
 * @author Tadas Gliaubicas <tadcka89@gmail.com>
 *
 * @since 9/1/14 8:30 PM
 */
class InMemoryRouteManager extends RouteManager
{
    /**
     * @var RouteManagerInterface
     */
    private $routeManager;

    /**
     * @var array|RouteInterface[]
     */
    private $routes = array();

    /**
     * Constructor.
     *
     * @param RouteManagerInterface $routeManager
     */
    public function __construct(RouteManagerInterface $routeManager)
    {
        $this->routeManager = $routeManager;
    }

    /**
     * {@inheritdoc}
     */
    public function findAllNameAndPattern()
    {
        return $this->routeManager->findAllNameAndPattern();
    }

    /**
     * {@inheritdoc}
     */
    public function findByName($name)
    {
        if (isset($this->routes[$name])) {
            return $this->routes[$name];
        }

        return $this->routeManager->findByName($name);
    }

    /**
     * {@inheritdoc}
     */
    public function findVisibleByName($name)
    {
        if (isset($this->routes[$name])) {
            $route = $this->routes[$name];

            return $route->isVisible() ? $route : null;
        }

        return $this->routeManager->findVisibleByName($name);
    }

    /**
     * {@inheritdoc}
     */
    public function findByNames(array $names)
    {
        $routes = array();
        $diffNames = array_diff($names, array_keys($this->routes));

        foreach ($this->routes as $name => $route) {
            if (in_array($name, $names)) {
                $routes[] = $route;
            }
        }

        return array_merge($routes, $this->routeManager->findByNames($diffNames));
    }

    /**
     * {@inheritdoc}
     */
    public function findVisibleByNames(array $names)

This method seems to be duplicated in your project.

    {
        $routes = array();
        $diffNames = array_diff($names, array_keys($this->routes));

        foreach ($this->routes as $name => $route) {
            if (in_array($name, $names) && $route->isVisible()) {
                $routes[] = $route;
            }
        }

        return array_merge($routes, $this->routeManager->findVisibleByNames($diffNames));
    }

    /**
     * {@inheritdoc}
     */
    public function findByRoutePattern($routePattern)
    {
        foreach ($this->routes as $route) {
            if ($routePattern === $route->getRoutePattern()) {
                return $route;
            }
        }

        return $this->routeManager->findByRoutePattern($routePattern);
    }

    /**
     * {@inheritdoc}
     */
    public function findByRoutePatterns(array $routePatterns)

This method seems to be duplicated in your project.

    {
        $result = array();
        foreach ($routePatterns as $routePattern) {
            foreach ($this->routes as $route) {
                if ($routePattern === $route->getRoutePattern()) {
                    $result[$routePattern] = $route;
                }
            }
        }

        $diffRoutePatterns = array_diff($routePatterns, array_keys($result));

        return array_merge(array_values($result), $this->routeManager->findByRoutePatterns($diffRoutePatterns));
    }

    /**
     * {@inheritdoc}
     */
    public function findVisibleByRoutePatterns(array $routePatterns)

This method seems to be duplicated in your project.

    {
        $result = array();
        foreach ($routePatterns as $routePattern) {
            foreach ($this->routes as $route) {
                if (($routePattern === $route->getRoutePattern()) && $route->isVisible()) {
                    $result[$routePattern] = $route;
                }
            }
        }

        $diffRoutePatterns = array_diff($routePatterns, array_keys($result));

        return array_merge(array_values($result), $this->routeManager->findVisibleByRoutePatterns($diffRoutePatterns));
    }

    /**
     * {@inheritdoc}
     */
    public function all()
    {
        $routes = $this->routes;
        foreach ($this->routeManager->all() as $route) {
            if (false === isset($routes[$route->getName()])) {
                $routes[$route->getName()] = $route;
            }
        }

        return array_values($routes);
    }

    /**
     * {@inheritdoc}
     */
    public function add(RouteInterface $route, $save = false)
    {
        if (!$route->getName()) {
            throw new RoutingRuntimeException('Route name is empty!');
        }

        $this->routes[$route->getName()] = $route;
        $this->routeManager->add($route, $save);
    }

    /**
     * {@inheritdoc}
     */
    public function remove(RouteInterface $route, $save = false)
    {
        if (isset($this->routes[$route->getName()])) {
            unset($this->routes[$route->getName()]);
        }
        $this->routeManager->remove($route, $save);
    }

    /**
     * {@inheritdoc}
     */
    public function save()
    {
        $this->routeManager->save();
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        $this->routes = array();
        $this->routeManager->clear();
    }

    /**
     * {@inheritdoc}
     */
    public function getClass()
    {
        return $this->routeManager->getClass();
    }
}