WebServCo\Framework\Traits\RequestProcessTrait

Complexity

Total Complexity

40

Size/Duplication

Total Lines	232
Duplicated Lines	0 %

Importance

Changes	7
Bugs	0	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	processPost()	0	7	2
A	init()	0	23	5
A	setMethod()	0	14	3
A	clearGlobals()	0	14	4
A	setBody()	0	4	1
A	sanitize()	0	10	3
A	setPath()	0	16	2
A	setFilename()	0	7	2
A	processCli()	0	14	5
A	process()	0	7	2
B	processHttp()	0	49	8
A	getQueryString()	0	9	3

<?php

declare(strict_types=1);

namespace WebServCo\Framework\Traits;

use WebServCo\Framework\Http\Method;

trait RequestProcessTrait
{
    abstract public function clearData(): bool;

    /**
     * @param mixed $key Can be an array, a string,
     *                          or a special formatted string
     *                          (eg 'i18n/lang').
     * @param mixed $value The value to be stored.
     * @return bool True on success and false on failure.
     */
    abstract public function setData($key, $value): bool;

    /**
    * @param mixed $key Can be an array, a string,
    *                          or a special formatted string
    *                          (eg 'i18n/lang').
    * @param mixed $defaultValue
    * @return mixed
    */
    abstract public function setting($key, $defaultValue = null);

    /**
    * Data value can be another array, for example _SERVER in CLI ("argv" is an array)
    * Important: only first level is sanitized.
    *
    * @param array<string,array<int,string>|string> $data
    * @return array<string,array<int,string>|string>
    */
    public function sanitize(array $data): array
    {
        foreach ($data as $key => $value) {
            if (\is_string($value)) {
                // Sanitize only first level (prevents "argv" from being sanitized)
                $value = \WebServCo\Framework\Helpers\RequestHelper::sanitizeString($value);
            }
            $data[$key] = $value;
        }
        return $data;
    }

    /**
    * @param array<string,mixed> $server
    * @param array<string,string> $post
    */
    protected function init(array $server, array $post = []): bool
    {
        $this->server = $this->sanitize($server);

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

        $this->setBody();
        $this->setMethod();
        $this->setFilename();
        $this->setPath();

        $this->process();

        switch ($this->method) {
            case Method::GET:
            case Method::HEAD:
                break;
            case Method::POST:
                $this->processPost($post);
                break;
        }
        if ($this->setting('clear_globals', false)) {
            $this->clearGlobals();
        }
        return true;
    }

    protected function setBody(): bool
    {
        $this->body = (string) \file_get_contents('php://input');

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

        return true;
    }

    protected function setMethod(): bool
    {
        if (
            empty($this->server['REQUEST_METHOD']) ||
            !\in_array(
                $this->server['REQUEST_METHOD'],
                Method::getSupported(),
                true,
            )
        ) {
            return false;
        }
        $this->method = $this->server['REQUEST_METHOD'];

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

        return true;
    }

    protected function setFilename(): bool
    {
        if (empty($this->server['SCRIPT_NAME'])) {
            return false;
        }
        $this->filename = \basename($this->server['SCRIPT_NAME']);

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

        return true;
    }

    protected function setPath(): bool
    {
        if (empty($this->server['SCRIPT_NAME'])) {
            return false;
        }

        $this->path = \rtrim(

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

            \str_replace(
                $this->filename,
                '',
                $this->server['SCRIPT_NAME'],
            ),
            \DIRECTORY_SEPARATOR,
        );

        return true;
    }

    protected function clearGlobals(): bool
    {
        if (!empty($_GET)) {
            foreach ($_GET as $k => $v) {
                unset($_REQUEST[$k]);
            }

            $_GET = [];
        }

        if (!empty($_POST)) {
            $_POST = [];
        }
        return true;
    }

    /**
    * @param array<string,string> $post
    */
    protected function processPost(array $post = []): bool
    {
        $this->clearData();
        foreach ($post as $k => $v) {
            $this->setData(\WebServCo\Framework\Helpers\RequestHelper::sanitizeString((string) $k), $v);
        }
        return true;
    }

    protected function process(): bool
    {
        if (\WebServCo\Framework\Helpers\PhpHelper::isCli()) {
            return $this->processCli();
        }

        return $this->processHttp();
    }

    protected function processCli(): bool
    {
        if (isset($this->server['argv'][1])) {
            $this->target = $this->server['argv'][1];

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

        }
        if (isset($this->server['argv'][2])) {
            foreach ($this->server['argv'] as $k => $v) {
                if (\in_array($k, [0, 1], true)) {
                    continue;
                }
                $this->args[] = \WebServCo\Framework\Helpers\RequestHelper::sanitizeString($v);

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

            }
        }
        return true;
    }

    protected function processHttp(): bool
    {
        $string = null;
        switch (true) {
            case isset($this->server['REDIRECT_URL']):
                /**
                 * Specific situation:
                 * - rewrite is done in an external website,
                 * and current project is used a subfolder (symlink) of the main website.
                 * In that case the `REQUEST_URI` will contain the source (left part of the rewrite)
                 * and `REDIRECT_URL` will contain the actual target path (right part of the rewrite).
                 * So this needs to be before the `REQUEST_URI` check.
                 */
                $string = $this->server['REDIRECT_URL'];
                // Seems in this case the query string is not added, so check and added.
                if (!\strpos($string, '?')) {
                    $queryString = $this->getQueryString();
                    if ('' !== $queryString) {
                        $string = \sprintf('%s?%s', $string, $queryString);
                    }
                }
                break;
            case isset($this->server['REQUEST_URI']):
                $string = $this->server['REQUEST_URI'];
                break;
            case isset($this->server['PATH_INFO']):
                $string = $this->server['PATH_INFO'];
                break;
            case isset($this->server['ORIG_PATH_INFO']):
                $string = $this->server['ORIG_PATH_INFO'];
                break;
            case !empty($this->server['QUERY_STRING']):
                $string = $this->server['ORIG_PATH_INFO'];
                break;
            default:
                break;
        }
        [$target, $queryString, $suffix] = \WebServCo\Framework\Helpers\RequestHelper::parse(
            $string,
            $this->path,
            $this->filename,
            $this->setting('suffixes', []),
        );
        $this->target = \WebServCo\Framework\Helpers\RequestHelper::sanitizeString(\urldecode($target));

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

        $this->query = \WebServCo\Framework\Helpers\RequestHelper::format(

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

            \WebServCo\Framework\Helpers\RequestHelper::sanitizeString($queryString),
        );
        $this->suffix = $suffix;

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

        return true;
    }

    private function getQueryString(): string
    {
        switch (true) {
            case isset($this->server['REDIRECT_QUERY_STRING']):
                return $this->server['REDIRECT_QUERY_STRING'];
            case isset($this->server['QUERY_STRING']):
                return $this->server['QUERY_STRING'];
            default:
                return '';
        }
    }
}