Ffcms\Core\Network\Request::runMultiLanguage()

Complexity

Conditions	15
Paths	9

Size

Total Lines	50
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	Request::getPathWithoutControllerAction()	0	17	4
A	Request::getPathInfo()	0	7	3

<?php

namespace Ffcms\Core\Network;

use Ffcms\Core\App;
use Ffcms\Core\Helper\Type\Str;
use Symfony\Component\HttpFoundation\Request as FoundationRequest;

/**
 * Class Request. Classic implementation of httpfoundation.request with smooth additions and changes which allow
 * working as well as in ffcms.
 * @package Ffcms\Core\Network
 */
class Request extends FoundationRequest
{
    use Request\MvcFeatures, Request\MultiLanguageFeatures, Request\RouteMapFeatures;

    /**
     * Request constructor.
     * @inheritdoc
     * @param array $query
     * @param array $request
     * @param array $attributes
     * @param array $cookies
     * @param array $files
     * @param array $server
     * @param null $content

Are you sure the doc-type for parameter $content is correct as it would always require null to be passed?

     */
    public function __construct(array $query = [], array $request = [], array $attributes = [], array $cookies = [], array $files = [], array $server = [], $content = null)
    {
        parent::__construct($query, $request, $attributes, $cookies, $files, $server, $content);
        $this->searchRedirect();
        $this->runMultiLanguage();
        $this->runRouteBinding();
        $this->loadTrustedProxies();
    }

    /**
     * Sets the parameters for this request.
     *
     * This method also re-initializes all properties.
     *
     * @param array $query The GET parameters
     * @param array $request The POST parameters
     * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
     * @param array $cookies The COOKIE parameters
     * @param array $files The FILES parameters
     * @param array $server The SERVER parameters
     * @param string $content The raw body data
     *
     * @api
     */
    public function initialize(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
    {
        parent::initialize($query, $request, $attributes, $cookies, $files, $server, $content);

        $basePath = trim(App::$Properties->get('basePath'), '/');

It seems like Ffcms\Core\App::Properties->get('basePath') can also be of type false; however, parameter $str of trim() does only seem to accept string, maybe add an additional type check?

        if ($basePath !== null && Str::length($basePath) > 0) {
            $basePath = '/' . $basePath;
        }

        if (!defined('env_no_uri') || env_no_uri === false) {

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

            $basePath .= '/' . strtolower(env_name);

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

        }

        // we never try to use path's without friendly url's
        $this->basePath = $this->baseUrl = $basePath;
    }

    /**
     * Set trusted proxies from configs
     */
    private function loadTrustedProxies()
    {
        $proxies = App::$Properties->get('trustedProxy');
        if ($proxies === null || Str::likeEmpty($proxies)) {

It seems like $proxies can also be of type false; however, parameter $string of Ffcms\Core\Helper\Type\Str::likeEmpty() does only seem to accept null|string, maybe add an additional type check?

            return;
        }

        $pList = explode(',', $proxies);

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

        $resultList = [];
        foreach ($pList as $proxy) {
            $resultList[] = trim($proxy);
        }
        self::setTrustedProxies($resultList);
    }

    /**
     * Get pathway as string
     * @return string
     */
    public function getPathInfo()
    {
        $route = $this->languageInPath ? Str::sub(parent::getPathInfo(), Str::length($this->language) + 1) : parent::getPathInfo();
        if (!Str::startsWith('/', $route)) {
            $route = '/' . $route;
        }
        return $route;
    }

    /**
     * Get pathway without current controller/action path
     * @return string
     */
    public function getPathWithoutControllerAction(): ?string
    {
        $path = trim($this->getPathInfo(), '/');
        if ($this->aliasPathTarget !== null) {
            $path = trim($this->aliasPathTarget, '/');
        }

        $pathArray = explode('/', $path);
        if ($pathArray[0] === Str::lowerCase($this->getController())) {
            // unset controller
            array_shift($pathArray);
            if ($pathArray[0] === Str::lowerCase($this->getAction())) {
                // unset action
                array_shift($pathArray);
            }
        }
        return trim(implode('/', $pathArray), '/');
    }

    /**
     * Get current full request URI
     * @return string
     */
    public function getFullUrl(): string
    {
        return $this->getSchemeAndHttpHost() . $this->getRequestUri();
    }

    /**
     * Get base path from current environment without basePath of subdirectories
     * @return string
     */
    public function getInterfaceSlug(): string
    {
        $path = $this->getBasePath();
        $subDir = App::$Properties->get('basePath');
        if ($subDir !== '/') {
            $offset = (int)Str::length($subDir);

It seems like $subDir can also be of type false; however, parameter $string of Ffcms\Core\Helper\Type\Str::length() does only seem to accept null|string, maybe add an additional type check?

            $path = Str::sub($path, --$offset);
        }
        return $path;

The expression return $path could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }
}