Jaxon\Request\Handler\ParameterReader

Complexity

Total Complexity

35

Size/Duplication

Total Lines	295
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	convertStringToBool()	0	11	3
A	setUtf8Decoder()	0	28	4
A	setParamDecoder()	0	20	4
A	__construct()	0	7	1
A	getRequestParameters()	0	23	4
A	args()	0	11	2
A	parseUrl()	0	3	1
A	convertValue()	0	15	6
A	decodeRequestParameter()	0	15	4
A	decodeUtf8Parameters()	0	12	3
A	decodeUtf8Parameter()	0	9	2
A	uri()	0	3	1

<?php

/**
 * ParameterReader.php
 *
 * This class processes the input arguments from the GET or POST data of the request.
 * If this is a request for the initial page load, no arguments will be processed.
 * During a jaxon request, any arguments found in the GET or POST will be converted to a PHP array.
 *
 * @package jaxon-core

Package name "jaxon-core" is not valid; consider "Jaxoncore" instead

 * @author Jared White

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author J. Max Wilson

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Joseph Woolley

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Steffen Konerow

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

 * @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White  & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

 * @copyright 2016 Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

PHP version not specified

Missing @category tag in file comment

namespace Jaxon\Request\Handler;

use Jaxon\App\Config\ConfigManager;
use Jaxon\App\I18n\Translator;
use Jaxon\Di\Container;
use Jaxon\Exception\RequestException;
use Jaxon\Utils\Http\UriDetector;
use Jaxon\Utils\Http\UriException;

use function array_map;
use function call_user_func;
use function floor;
use function function_exists;
use function iconv;
use function intval;
use function is_array;
use function is_string;
use function json_decode;
use function mb_convert_encoding;
use function strcasecmp;
use function strlen;
use function substr;
use function utf8_decode;

class ParameterReader

Missing doc comment for class ParameterReader

{
    /**
     * @var Container
     */
    protected $di;

Expected 1 blank line(s) before first member var; 0 found

    /**
     * @var ConfigManager
     */
    protected $xConfigManager;

    /**
     * @var Translator
     */
    protected $xTranslator;

    /**
     * @var UriDetector
     */
    private $xUriDetector;

    /**
     * The function which decodes input parameters.
     *
     * @var callable
     */
    private $cParamDecoder;

    /**
     * The function which decodes utf8 string.
     *
     * @var callable
     */
    private $cUtf8Decoder;

    /**
     * The constructor
     *
     * @param Container $di

Missing parameter comment

Expected 5 spaces after parameter type; 1 found

     * @param ConfigManager $xConfigManager

Missing parameter comment

     * @param Translator $xTranslator

Missing parameter comment

Expected 4 spaces after parameter type; 1 found

     * @param UriDetector $xUriDetector

Missing parameter comment

Expected 3 spaces after parameter type; 1 found

     */
    public function __construct(Container $di, ConfigManager $xConfigManager,

Expected 2 blank lines before function; 1 found

        Translator $xTranslator, UriDetector $xUriDetector)
    {
        $this->di = $di;

Equals sign not aligned with surrounding assignments; expected 13 spaces but found 1 space

        $this->xConfigManager = $xConfigManager;
        $this->xTranslator = $xTranslator;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $this->xUriDetector = $xUriDetector;

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

    }

Expected 2 blank lines after function; 1 found

    /**
     * Choose the function to use to decode input data.
     *
     * @return void
     */
    private function setParamDecoder()
    {
        // Parameters are url encoded when uploading files
        $aServerParams = $this->di->getRequest()->getServerParams();
        $sContentType = '';
        if(isset($aServerParams['CONTENT_TYPE']))
        {
            $sContentType = $aServerParams['CONTENT_TYPE'];
        }
        elseif(isset($aServerParams['HTTP_CONTENT_TYPE']))
        {
            $sContentType = $aServerParams['HTTP_CONTENT_TYPE'];
        }
        $sType = 'multipart/form-data';
        if(strncmp($sContentType, $sType, strlen($sType)) !== 0)
        {
            $this->cParamDecoder = function($sParam) { return $sParam; };
            return;
        }
        $this->cParamDecoder = function($sParam) { return urldecode($sParam); };
    }

Expected 2 blank lines after function; 1 found

    /**
     * Choose the function to use to decode input data.
     *
     * @return void
     * @throws RequestException
     */
    private function setUtf8Decoder()
    {
        // By default, no decoding
        $this->cUtf8Decoder = function($sStr) {
            return $sStr;
        };
        $sEncoding = $this->xConfigManager->getOption('core.encoding', '');

Equals sign not aligned with surrounding assignments; expected 10 spaces but found 1 space

        if(function_exists('iconv'))
        {
            $this->cUtf8Decoder = function($sStr) use($sEncoding) {
                return iconv("UTF-8", $sEncoding . '//TRANSLIT', $sStr);
            };
        }
        elseif(function_exists('mb_convert_encoding'))
        {
            $this->cUtf8Decoder = function($sStr) use($sEncoding) {
                return mb_convert_encoding($sStr, $sEncoding, "UTF-8");
            };
        }
        elseif($sEncoding === "ISO-8859-1")
        {
            $this->cUtf8Decoder = function($sStr) {
                return utf8_decode($sStr);
            };
        }
        else
        {
            throw new RequestException($this->xTranslator->trans('errors.request.conversion'));
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Converts a string to a bool var
     *
     * @param string $sValue    The string to be converted

Expected 1 spaces after parameter name; 4 found

     *
     * @return bool
     */
    private function convertStringToBool(string $sValue): bool
    {
        if(strcasecmp($sValue, 'true') === 0)
        {
            return true;
        }
        if(strcasecmp($sValue, 'false') === 0)
        {
            return false;
        }
        return (intval($sValue) !== 0);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Convert a Jaxon request argument to its value
     *
     * Depending on its first char, the Jaxon request argument is converted to a given type.
     *
     * @param string $sValue    The keys of the options in the file

Expected 1 spaces after parameter name; 4 found

     *
     * @return string|bool|integer|double|null
     */
    private function convertValue(string $sValue)
    {
        $cType = substr($sValue, 0, 1);
        $sValue = substr($sValue, 1);
        switch($cType)
        {
        case 'S':
            return $sValue;
        case 'B':
            return $this->convertStringToBool($sValue);
        case 'N':
            return ($sValue == floor($sValue) ? (int)$sValue : (float)$sValue);

$sValue of type string is incompatible with the type double|integer expected by parameter $num of floor().

        case '*':
        default:
            return null;
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Decode and convert a Jaxon request argument
     *
     * @param string $sParam    The Jaxon request argument

Expected 1 spaces after parameter name; 4 found

     *
     * @return mixed
     */
    private function decodeRequestParameter(string $sParam)
    {
        if($sParam === '')
        {
            return $sParam;
        }

        $sParam = call_user_func($this->cParamDecoder, $sParam);

        $xJson = json_decode($sParam, true);
        if($xJson !== null && $sParam != $xJson)
        {
            return $xJson;
        }
        return $this->convertValue($sParam);
    }

Expected 2 blank lines after function; 1 found

    /**
     * @return array
     */
    private function getRequestParameters(): array
    {
        $aParams = [];
        $xRequest = $this->di->getRequest();
        $aBody = $xRequest->getParsedBody();

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        if(is_array($aBody))
        {
            if(isset($aBody['jxnargs']))
            {
                $aParams = $aBody['jxnargs'];
            }
        }
        else
        {
            $aParams = $xRequest->getQueryParams();
            if(isset($aParams['jxnargs']))
            {
                $aParams = $aParams['jxnargs'];
            }
        }
        return array_map(function($sParam) {
            return $this->decodeRequestParameter((string)$sParam);
        }, $aParams);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Decode a Jaxon request argument from UTF8
     *
     * @param mixed $xValue    The value of the argument being decoded

Expected 1 spaces after parameter name; 4 found

     *
     * @return mixed
     */
    private function decodeUtf8Parameter($xValue)
    {
        if(is_string($xValue))
        {
            return call_user_func($this->cUtf8Decoder, $xValue);
        }
        // elseif(is_numeric($xValue) || is_bool($xValue))
        {
            return $xValue;
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Decode an array of Jaxon request arguments from UTF8
     *
     * @param array $aParams

Missing parameter comment

     *
     * @return array
     */
    private function decodeUtf8Parameters(array $aParams): array
    {
        $aValues = [];
        foreach($aParams as $sKey => $xValue)
        {
            // Decode the key
            $sKey = call_user_func($this->cUtf8Decoder, $sKey);
            // Decode the value
            $aValues[$sKey] = is_array($xValue) ?

Expected 1 space after "?"; newline found

                $this->decodeUtf8Parameters($xValue) : $this->decodeUtf8Parameter($xValue);
        }
        return $aValues;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Return the array of arguments from the GET or POST data
     *
     * @return array
     * @throws RequestException
     */
    public function args(): array
    {
        $this->setParamDecoder();
        $aParams = $this->getRequestParameters();
        if(!$this->xConfigManager->getOption('core.decode_utf8'))
        {
            return $aParams;
        }
        $this->setUtf8Decoder();
        $this->xConfigManager->setOption('core.decode_utf8', false);
        return $this->decodeUtf8Parameters($aParams);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the URI of the current request
     *
     * @throws UriException
     */

Missing @return tag in function comment

    public function uri(): string
    {
        return $this->xUriDetector->detect($this->di->getRequest()->getServerParams());
    }

Expected 2 blank lines after function; 1 found

    /**
     * Make the specified URL suitable for redirect
     *
     * @param string $sURL    The relative or fully qualified URL

Expected 1 spaces after parameter name; 4 found

     *
     * @return string
     */
    public function parseUrl(string $sURL): string
    {
        return $this->xUriDetector->redirect($sURL, $this->di->getRequest()->getServerParams());
    }

Expected 2 blank lines after function; 0 found

}