Ffcms\Core\Network\Request\RouteMapFeatures

Complexity

Total Complexity

21

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	runRouteBinding()	0	27	8
A	getStaticAlias()	0	3	1
A	getCallbackAlias()	0	3	1
A	findDynamicCallbacks()	0	11	4
A	isPathInjected()	0	3	2
A	findStaticAliases()	0	29	5

<?php

namespace Ffcms\Core\Network\Request;

use Ffcms\Core\App;
use Ffcms\Core\Helper\Type\Any;
use Ffcms\Core\Helper\Type\Arr;
use Ffcms\Core\Helper\Type\Str;
use Symfony\Component\HttpFoundation\RedirectResponse;

/**
 * Trait RouteMapFeatures. Process alias and callback route address bindings
 * @package Ffcms\Core\Network\Request
 */
trait RouteMapFeatures
{
    // special variable for route aliasing
    protected $aliasPathTarget;
    // special variable for route callback binding
    protected $callbackClass;

    /**
     * Build static and dynamic path aliases for working set
     * @return void
     */
    private function runRouteBinding(): void
    {
        // calculated depend of language
        $pathway = $this->getPathInfo();

It seems like getPathInfo() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        /** @var array $routing */
        $routing = App::$Properties->getAll('Routing');

        // try to work with static aliases
        if (Any::isArray($routing) && isset($routing['Alias'], $routing['Alias'][env_name])) {

The constant Ffcms\Core\Network\Request\env_name was not found. Maybe you did not declare it correctly or list all dependencies?

            $pathway = $this->findStaticAliases($routing['Alias'][env_name], $pathway);
        }

        $this->setPathdata(explode('/', trim($pathway, '/')));

It seems like setPathdata() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        // set default controller and action for undefined data
        if (!$this->action) {
            $this->action = 'Index';

The property action does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        // empty or contains backslashes? set to main
        if (!$this->controller || Str::contains('\\', $this->controller)) {
            $this->controller = 'Main';

The property controller does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        // find callback injection in routing configs (calculated in App::run())
        if (Any::isArray($routing) && isset($routing['Callback'], $routing['Callback'][env_name])) {
            $this->findDynamicCallbacks($routing['Callback'][env_name], $this->controller);
        }
    }

    /**
     * Prepare static pathway aliasing for routing
     * @param array|null $map
     * @param string|null $pathway
     * @return string|null
     */
    private function findStaticAliases(?array $map = null, ?string $pathway = null): ?string
    {
        if (!$map) {
            return $pathway;
        }

        // current pathway is found as "old path" (or alias target). Make redirect to new pathway.
        if (Arr::in($pathway, $map)) {
            // find "new path" as binding uri slug
            $binding = array_search($pathway, $map, true);
            // build url to redirection
            $url = $this->getSchemeAndHttpHost() . $this->getBasePath() . '/';

It seems like getSchemeAndHttpHost() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like getBasePath() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            if (App::$Properties->get('multiLanguage')) {
                $url .= $this->language . '/';
            }
            $url .= ltrim($binding, '/');

It seems like $binding can also be of type false; however, parameter $str of ltrim() does only seem to accept string, maybe add an additional type check?

            $redirect = new RedirectResponse($url);
            $redirect->send();
            exit();

Using exit here is not recommended.

        }

        // current pathway request is equal to path alias. Set alias to property.
        if (array_key_exists($pathway, $map)) {
            $pathway = $map[$pathway];
            $this->aliasPathTarget = $pathway;
        }

        return $pathway;
    }

    /**
     * Prepare dynamic callback data for routing
     * @param array|null $map
     * @param string|null $controller
     * @return void
     */
    private function findDynamicCallbacks(array $map = null, ?string $controller = null): void
    {
        if (!$map) {
            return;
        }

        // try to find global callback for this controller slug
        if (array_key_exists($controller, $map)) {
            $class = (string)$map[$controller];
            if (!Str::likeEmpty($class)) {
                $this->callbackClass = $class;
            }
        }
    }


    /**
     * Get callback class alias if exist
     * @return null|string
     */
    public function getCallbackAlias(): ?string
    {
        return $this->callbackClass;
    }

    /**
     * Get static alias of pathway if exist
     * @return null|string
     */
    public function getStaticAlias(): ?string
    {
        return $this->aliasPathTarget;
    }

    /**
     * Check if current request is aliased by dynamic or static rule
     * @return bool
     */
    public function isPathInjected(): bool
    {
        return $this->callbackClass !== null || $this->aliasPathTarget !== null;
    }
}