DevOp\Core\Router\Route

Complexity

Total Complexity

10

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	compile()	0	30	5
A	getRegEx()	0	3	1
A	__construct()	0	6	1
A	getPattern()	0	3	1
A	getParameters()	0	3	1
A	getCallback()	0	3	1

<?php
namespace DevOp\Core\Router;

class Route
{

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

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

    /**
     * @var array
     */
    private $parameters = [];

    /**
     * @var object|callback|array
     */
    private $callback;

    /**
     * @param string $name
     * @param string $pattern
     * @param object|callback|array $callback
     */
    public function __construct($pattern, $callback)
    {
        $this->pattern = $pattern;
        $this->callback = $callback;
        
        $this->compile($pattern);
    }

    /**
     * @return stringsssss

The type DevOp\Core\Router\stringsssss was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function getRegEx()
    {
        return $this->regEx;

The expression return $this->regEx returns the type string which is incompatible with the documented return type DevOp\Core\Router\stringsssss.

    }

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

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

    /**
     * @return object|callback|array
     */
    public function getCallback()
    {
        return $this->callback;
    }

    public function compile($pattern)
    {
        $matches = [];
        preg_match_all('#\[(.*?)\]#s', $pattern, $matches, PREG_SET_ORDER);

        if (empty($matches)) {
            $this->regEx = "#^{$pattern}$#s";
            return;
        }

        $components = array_map(function($values) {
            return ['name' => $values[0], 'value' => $values[1]];
        }, $matches);

        $replaces = $parameters = [];

The assignment to $parameters is dead and can be removed.

        foreach ($components AS $route) {
            $placeholder = ltrim($route['value'], '/');
            $optional = substr($route['value'], 0, 1) === '/';
            if (strchr($placeholder, ':')) {
                list($parameter, $value) = explode(':', $placeholder);
                $regEx = "(?P<$parameter>{$value})";
                $this->parameters[] = $parameter;
            } else {
                $regEx = "(?P<$placeholder>[^/]++)";
                $this->parameters[] = $placeholder;
            }
            $replaces[$route['name']] = !$optional ? $regEx : "(?:/{$regEx})";
        }

        $this->regEx = sprintf("#^%s?$#s", str_replace(array_keys($replaces), array_values($replaces), $pattern));
    }
}