Anax\Route\Route

Complexity

Total Complexity

32

Size/Duplication

Total Lines	233
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

92.41%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	set()	0	12	2
B	checkPartAsArgument()	0	18	5
B	checkPartMatchingType()	0	23	5
A	matchPart()	0	19	4
B	matchRequestMethod()	0	9	6
C	match()	0	29	7
A	handle()	0	4	1
A	setName()	0	5	1
A	getRule()	0	4	1

<?php

namespace Anax\Route;

/**
 * A container for routes.
 *
 */
class Route
{

    /**
    * Properties
    *
    */
    private $name;           // A name for this route
    private $method;         // The methods to support
    private $rule;           // The rule for this route
    private $action;         // The callback to handle this route
    private $arguments = []; // Arguments for the callback



    /**
     * Set values for route.
     *
     * @param string            $rule   for this route
     * @param callable          $action callable to implement a controller for
     *                                  the route
     * @param null|string|array $method as request method to support
     *
     * @return $this
     */
    public function set($rule = null, $action = null, $method = null)
    {
        $this->rule = $rule;
        $this->action = $action;

        $this->method = $method;
        if (is_string($method)) {
            $this->method = [$method];
        }

        return $this;
    }



    /**
     * Check if part of route is a argument and optionally match type
     * as a requirement {argument:type}.
     *
     * @param string $rulePart   the rule part to check.
     * @param string $queryPart  the query part to check.
     * @param array  &$args      add argument to args array if matched
     *
     * @return boolean
     */
    private function checkPartAsArgument($rulePart, $queryPart, &$args)
    {
        if (substr($rulePart, -1) == "}"
            && !is_null($queryPart)
        ) {
            $part = substr($rulePart, 1, -1);
            $pos = strpos($part, ":");
            if ($pos !== false) {
                $type = substr($part, $pos + 1);
                if (! $this->checkPartMatchingType($queryPart, $type)) {

The expression $this->checkPartMatchingType($queryPart, $type) of type boolean|null is loosely compared to false; this is ambiguous if the boolean can be false. You might want to explicitly use !== null instead.

                    return false;
                }
            }
            $args[] = $queryPart;
            return true;
        }
        return false;
    }



    /**
     * Check if value is matching a certain type of values.
     *
     * @param string $rulePart   the rule part to check.

There is no parameter named $rulePart. Was it maybe removed?

     * @param string $queryPart  the query part to check.

There is no parameter named $queryPart. Was it maybe removed?

     * @param array  &$args      add argument to args array if matched
     *
     * @return boolean
     */
    private function checkPartMatchingType($value, $type)
    {
        switch ($type) {
            case "digit":
                return ctype_digit($value);
                break;

break is not strictly necessary here and could be removed.

            case "hex":
                return ctype_xdigit($value);
                break;

break is not strictly necessary here and could be removed.

            case "alpha":
                return ctype_alpha($value);
                break;

break is not strictly necessary here and could be removed.

            case "alphanum":
                return ctype_alnum($value);
                break;

break is not strictly necessary here and could be removed.

            default:
                return false;
        }
    }



    /**
     * Match part of rule and query.
     *
     * @param string $rulePart   the rule part to check.
     * @param string $queryPart  the query part to check.
     * @param array  &$args      add argument to args array if matched
     *
     * @return boolean
     */
    private function matchPart($rulePart, $queryPart, &$args)
    {
        $match = false;

$match is not used, you could remove the assignment.

        $first = isset($rulePart[0]) ? $rulePart[0] : '';
        switch ($first) {
            case '*':
                $match = true;
                break;

            case '{':
                $match = $this->checkPartAsArgument($rulePart, $queryPart, $args);
                break;

            default:
                $match = ($rulePart == $queryPart);
                break;
        }
        return $match;
    }



    /**
     * Check if the request method matches.
     *
     * @param string $method as request method
     *
     * @return boolean true if request method matches
     */
    public function matchRequestMethod($method)
    {
        if ($method && is_array($this->method) && !in_array($method, $this->method)
            || (is_null($method) && !empty($this->method))
        ) {
            return false;
        }
        return true;
    }



    /**
     * Check if the route matches a query and request method.
     *
     * @param string $query  to match against
     * @param string $method as request method
     *
     * @return boolean true if query matches the route
     */
    public function match($query, $method = null)
    {
        if (!$this->matchRequestMethod($method)) {
            return false;
        }

        // If default route, match anything
        if ($this->rule == "*") {
            return true;
        }

        // Check all parts to see if they matches
        $ruleParts  = explode('/', $this->rule);
        $queryParts = explode('/', $query);
        $ruleCount = max(count($ruleParts), count($queryParts));
        $args = [];

        for ($i = 0; $i < $ruleCount; $i++) {
            $rulePart  = isset($ruleParts[$i])  ? $ruleParts[$i]  : null;
            $queryPart = isset($queryParts[$i]) ? $queryParts[$i] : null;

            if (!$this->matchPart($rulePart, $queryPart, $args)) {
                return false;
            }
        }

        $this->arguments = $args;
        return true;
    }



    /**
     * Handle the action for the route.
     *
     * @return void
     */
    public function handle()
    {
        return call_user_func($this->action, ...$this->arguments);
    }



    /**
     * Set the name of the route.
     *
     * @param string $name set a name for the route
     *
     * @return $this
     */
    public function setName($name)
    {
        $this->name = $name;
        return $this;
    }



    /**
     * Get the rule for the route.
     *
     * @return string
     */
    public function getRule()
    {
        return $this->rule;
    }
}