Nip\Router\Route\AbstractRoute

Complexity

Total Complexity

27

Size/Duplication

Total Lines	213
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Test Coverage

Coverage

37.68%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	4
A	init()	0	3	1
A	__call()	0	4	1
A	assembleFull()	0	7	1
A	getBase()	0	11	3
A	setBase()	0	4	1
A	checkBase()	0	6	2
A	initBase()	0	6	1
A	generateBase()	0	7	2
A	replaceSubdomain()	0	13	2
A	getParams()	0	4	1
A	getMatches()	0	4	1
A	getUri()	0	4	1
A	getName()	0	8	2
A	setName()	0	4	1
A	initName()	0	4	1
A	getClassName()	0	4	1
A	assemble()	0	4	1

<?php

namespace Nip\Router\Route;

use Nip\Router\Parsers\Dynamic;
use Nip\Router\Route\Traits\HasMatchTrait;
use Nip\Router\Route\Traits\HasParserTrait;
use Nip\Router\Route\Traits\HasRequestTrait;
use Nip\Router\Route\Traits\HasTypeTrait;
use Nip\Router\Utility\MapTransform;
use Nip\Utility\Traits\NameWorksTrait;

/**
 * Class AbstractRoute
 * @package Nip\Router\Route
 */
abstract class AbstractRoute extends \Symfony\Component\Routing\Route
{
    use NameWorksTrait;
    use HasParserTrait;
    use HasTypeTrait;
    use HasRequestTrait;
    use HasMatchTrait;

    /**
     * @var string
     */
    protected $name = null;

    protected $base = null;

    /**
     * @var string
     */
    protected $uri;

    /**
     * AbstractRoute constructor.
     * @param bool $map
     * @param array $params
     */
    public function __construct($map = false, $params = [])
    {
        if ($map) {
            $parser = $this->getParser();
            $parser->setMap($map);
            if ($parser instanceof Dynamic) {
                $map = MapTransform::run($map);
            }
        }

        parent::__construct($map);


        if (count($params)) {
            $this->getParser()->setParams($params);
            $this->setDefaults($params);
        }
        $this->init();
    }


    public function init()
    {
    }

    /**
     * @param $name
     * @param $arguments
     * @return mixed
     */
    public function __call($name, $arguments)
    {
        return call_user_func_array([$this->getParser(), $name], $arguments);
    }

    /**
     * @param array $params
     * @return string
     */
    public function assembleFull($params = [])
    {
        $base = $this->getBase($params);
        $base = rtrim($base, "/");

        return $base . $this->assemble($params);
    }

    /**
     * @param array $params
     * @return string
     */
    public function getBase($params = [])
    {
        $this->checkBase($params);
        if (isset($params['_subdomain']) && !empty($params['_subdomain'])) {
            $base = $this->replaceSubdomain($params['_subdomain'], $this->base);

            return $base;
        }

        return $this->base;
    }

    /**
     * @param string $base
     */
    public function setBase($base)
    {
        $this->base = $base;
    }

    /** @noinspection PhpUnusedParameterInspection
     * @param array $params
     */
    public function checkBase($params = [])
    {
        if ($this->base === null) {
            $this->initBase($params);
        }
    }

    /** @noinspection PhpUnusedParameterInspection
     * @param array $params
     */
    public function initBase($params = [])
    {
        $this->setBase(
            $this->generateBase($params)
        );
    }

    /**
     * @param $params
     * @return string
     */
    protected function generateBase($params)

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

    {
        if (function_exists('request')) {
            return request()->getBaseUrl();
        }
        return $this->getRequest()->getBaseUrl();
    }

    /**
     * @param $subdomain
     * @param $url
     * @return mixed
     */
    public function replaceSubdomain($subdomain, $url)
    {
        $host = parse_url($url, PHP_URL_HOST);
        $parts = explode('.', $host);
        if (count($parts) > 2) {
            array_shift($parts);
        }

        array_unshift($parts, $subdomain);
        $newHost = implode('.', $parts);

        return str_replace($host, $newHost, $url);
    }

    /**
     * @param array $params
     * @return string
     */
    public function assemble($params = [])
    {
        return $this->getParser()->assemble($params);
    }

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

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

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

    /**
     * @return string
     */
    public function getName()
    {
        if ($this->name == null) {
            $this->initName();
        }

        return $this->name;
    }

    /**
     * @param string $name
     */
    public function setName($name)
    {
        $this->name = $name;
    }

    public function initName()
    {
        $this->setName($this->getClassName());
    }

    /**
     * @return string
     */
    public function getClassName()
    {
        return get_class($this);
    }
}