Codeburner\Router\Parser

Complexity

Total Complexity

14

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	parsePattern()	0	10	1
A	parseSegments()	0	8	3
A	buildSegments()	0	17	4
A	getWildcards()	0	7	2
A	getWildcardTokens()	0	4	1
A	getWildcard()	0	4	2
A	setWildcard()	0	5	1

<?php

/**
 * Codeburner Framework.
 *
 * @author Alex Rohleder <contato@alexrohleder.com.br>
 * @copyright 2016 Alex Rohleder
 * @license http://opensource.org/licenses/MIT
 */

namespace Codeburner\Router;

use Codeburner\Router\Exceptions\BadRouteException;

/**
 * Representation of a group of several routes with same
 * controller and respecting the resourceful actions.
 *
 * @author Alex Rohleder <contato@alexrohleder.com.br>
 */

class Parser
{

    /**
     * These regex define the structure of a dynamic segment in a pattern.
     *
     * @var string
     */

    const DYNAMIC_REGEX = "{\s*(\w*)\s*(?::\s*([^{}]*(?:{(?-1)}*)*))?\s*}";

    /**
     * Some regex wildcards for easily definition of dynamic routes. ps. all keys and values must start with :
     *
     * @var array
     */

    protected $wildcards = [
        ":uid"     => ":uid-[a-zA-Z0-9]",
        ":slug"    => ":[a-z0-9-]",
        ":string"  => ":\w",
        ":int"     => ":\d",
        ":integer" => ":\d",
        ":float"   => ":[-+]?\d*?[.]?\d",
        ":double"  => ":[-+]?\d*?[.]?\d",
        ":hex"     => ":0[xX][0-9a-fA-F]",
        ":octal"   => ":0[1-7][0-7]",
        ":bool"    => ":1|0|true|false|yes|no",
        ":boolean" => ":1|0|true|false|yes|no",
    ];

    /**
     * Separate routes pattern with optional parts into n new patterns.
     *
     * @param string $pattern
     *
     * @throws BadRouteException
     * @return array
     */

    public function parsePattern($pattern)
    {
        $withoutClosing = rtrim($pattern, "]");
        $closingNumber  = strlen($pattern) - strlen($withoutClosing);

        $segments = preg_split("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\[~x", $withoutClosing);
        $this->parseSegments($segments, $closingNumber, $withoutClosing);

        return $this->buildSegments($segments);
    }

    /**
     * Parse all the possible patterns seeking for an incorrect or incompatible pattern.
     *
     * @param string[] $segments       Segments are all the possible patterns made on top of a pattern with optional segments.
     * @param int      $closingNumber  The count of optional segments.
     * @param string   $withoutClosing The pattern without the closing token of an optional segment. aka: ]
     *
     * @throws BadRouteException
     */

    protected function parseSegments(array $segments, $closingNumber, $withoutClosing)
    {
        if ($closingNumber !== count($segments) - 1) {
            if (preg_match("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\]~x", $withoutClosing)) {
                   throw new BadRouteException(BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
            } else throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
        }
    }

    /**
     * @param string[] $segments
     *
     * @throws BadRouteException
     * @return array
     */

    protected function buildSegments(array $segments)
    {
        $pattern  = "";
        $patterns = [];
        $wildcardTokens = array_keys($this->wildcards);
        $wildcardRegex  = $this->wildcards;

        foreach ($segments as $n => $segment) {
            if ($segment === "" && $n !== 0) {
                throw new BadRouteException(BadRouteException::EMPTY_OPTIONAL_PARTS);
            }

            $patterns[] = $pattern .= str_replace($wildcardTokens, $wildcardRegex, $segment);
        }

        return $patterns;
    }

    /**
     * @return string[]
     */

    public function getWildcards()
    {
        $wildcards = [];
        foreach ($this->wildcards as $token => $regex)
            $wildcards[substr($token, 1)] = substr($regex, 1);
        return $wildcards;
    }

    /**
     * @return string[]
     */

    public function getWildcardTokens()
    {
        return $this->wildcards;
    }

    /**
     * @param string $wildcard
     * @return string|null
     */

    public function getWildcard($wildcard)
    {
        return isset($this->wildcards[":$wildcard"]) ? substr($this->wildcards[":$wildcard"], 1) : null;
    }

    /**
     * @param string $wildcard
     * @param string $pattern
     *
     * @return self
     */

    public function setWildcard($wildcard, $pattern)
    {
        $this->wildcards[":$wildcard"] = ":$pattern";
        return $this;
    }

}