ArgumentManager::_decode_utf8_argument() - Code Metrics - Inspection of "Renamed classes." - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 7c83a0...cd350b )

by Thierry
created 2022-03-14 23:12 UTC
ArgumentManager::_decode_utf8_argument() A

↳ Parent: ArgumentManager
Complexity

Conditions	6
Paths	5
Size

Total Lines	20
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	6
eloc	9
nc	5
nop	3
dl	0
loc	20
rs	9.2222
c	0
b	0
f	0
<?php

/**
 * ArgumentManager.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

 * @author Jared White

 * @author J. Max Wilson

 * @author Joseph Woolley

 * @author Steffen Konerow

 * @author Thierry Feuzeu <[email protected]>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson

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

 * @copyright 2016 Thierry Feuzeu <[email protected]>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */


namespace Jaxon\Request\Handler;

use Jaxon\Utils\Config\Config;
use Jaxon\Utils\Translation\Translator;
use Jaxon\Exception\RequestException;

use function strcasecmp;
use function is_numeric;
use function is_string;
use function is_array;
use function is_bool;
use function substr;
use function strlen;
use function floor;
use function json_decode;
use function call_user_func;
use function array_walk;
use function function_exists;
use function iconv;
use function mb_convert_encoding;
use function utf8_decode;

class ArgumentManager

{
    /*
     * Request methods
     */

    const METHOD_UNKNOWN = 0;
    const METHOD_GET = 1;
$a = "a";
$ab = "ab";
$abc = "abc";
    const METHOD_POST = 2;
$a = "a";
$ab = "ab";
$abc = "abc";

    /**
     * @var Config
     */
    protected $xConfig;

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

    /**
     * An array of arguments received via the GET or POST parameter jxnargs.
     *
     * @var array
     */
    private $aArgs;

    /**
     * Stores the method that was used to send the arguments from the client.
     * Will be one of: self::METHOD_UNKNOWN, self::METHOD_GET, self::METHOD_POST.
     *
     * @var integer
     */
    private $nMethod;

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

    /**
     * The constructor
     *
     * Get and decode the arguments of the HTTP request
     *
     * @param Config $xConfig

     * @param Translator $xTranslator

     */
    public function __construct(Config $xConfig, Translator $xTranslator)

    {
        $this->xConfig = $xConfig;
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->xTranslator = $xTranslator;
        $this->aArgs = [];
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->nMethod = self::METHOD_UNKNOWN;
$a = "a";
$ab = "ab";
$abc = "abc";

        if(isset($_POST['jxnargs']))
        {
            $this->nMethod = self::METHOD_POST;
            $this->aArgs = $_POST['jxnargs'];
$a = "a";
$ab = "ab";
$abc = "abc";
        }
        elseif(isset($_GET['jxnargs']))
        {
            $this->nMethod = self::METHOD_GET;
            $this->aArgs = $_GET['jxnargs'];
$a = "a";
$ab = "ab";
$abc = "abc";
        }
    }


    /**
     * Return the method that was used to send the arguments from the client
     *
     * The method is one of: self::METHOD_UNKNOWN, self::METHOD_GET, self::METHOD_POST.
     *
     * @return int
     */
    public function getRequestMethod(): int
    {
        return $this->nMethod;
    }


    /**
     * Return true if the current request method is GET
     *
     * @return bool
     */
    public function requestMethodIsGet(): bool
    {
        return ($this->getRequestMethod() === self::METHOD_GET);
    }


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

     *
     * @return bool
     */
    private function __convertStringToBool(string $sValue): bool

    {
        if(strcasecmp($sValue, 'true') === 0)
        {
            return true;
        }
        if(strcasecmp($sValue, 'false') === 0)
        {
            return false;
        }
        if(is_numeric($sValue))
        {
            return ($sValue !== '0');
        }
        return false;
    }


    /**
     * 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

     *
     * @return string|bool|integer|double|null
     */
    private function __convertValue(string $sValue)

    {
        $cType = substr($sValue, 0, 1);
        $sValue = substr($sValue, 1);
        switch($cType)
        {
        case 'S':
            $value = !$sValue ? '' : $sValue;
            break;
        case 'B':
            $value = $this->__convertStringToBool($sValue);
            break;
        case 'N':
            $value = ($sValue == floor($sValue) ? (int)$sValue : (float)$sValue);
            $value = ($sValue == floor(/** @scrutinizer ignore-type */ $sValue) ? (int)$sValue : (float)$sValue);
            break;
        case '*':
        default:
            $value = null;
            break;
        }
        return $value;
    }


    /**
     * Decode and convert an Jaxon request argument from JSON
     *
     * @param string $sArg    The Jaxon request argument

     *
     * @return void
     */
    private function __argumentDecode(string &$sArg)

    {
        if($sArg === '')
        {
            return;
        }

        // Arguments are url encoded when uploading files
        $sType = 'multipart/form-data';
$a = "a";
$ab = "ab";
$abc = "abc";
        $nLen = strlen($sType);
$a = "a";
$ab = "ab";
$abc = "abc";
        $sContentType = '';
        if(isset($_SERVER['CONTENT_TYPE']))
        {
            $sContentType = substr($_SERVER['CONTENT_TYPE'], 0, $nLen);
        }
        elseif(isset($_SERVER['HTTP_CONTENT_TYPE']))
        {
            $sContentType = substr($_SERVER['HTTP_CONTENT_TYPE'], 0, $nLen);
        }
        if($sContentType == $sType)
        {
            $sArg = urldecode($sArg);
        }

        $data = json_decode($sArg, true);

        if($data !== null && $sArg != $data)
        {
            $sArg = $data;
        }
        else
        {
            $sArg = $this->__convertValue($sArg);
        }
    }


    /**
     * Decode an Jaxon request argument from UTF8
     *
     * @param array $aDst    An array to store the decoded arguments

     * @param string $sKey    The key of the argument being decoded

     * @param string|array $mValue    The value of the argument being decoded

     *
     * @return void
     */
    private function _decode_utf8_argument(array &$aDst, string $sKey, $mValue)

    {
        // Decode the key
        $sDestKey = call_user_func($this->cUtf8Decoder, $sKey);

        if(is_array($mValue))
        {
            $aDst[$sDestKey] = [];
            foreach($mValue as $_sKey => &$_mValue)
            {
                $this->_decode_utf8_argument($aDst[$sDestKey], $_sKey, $_mValue);
            }
        }
        elseif(is_numeric($mValue) || is_bool($mValue))
        {
            $aDst[$sDestKey] = $mValue;
        }
        elseif(is_string($mValue))

        {
            $aDst[$sDestKey] = call_user_func($this->cUtf8Decoder, $mValue);
        }
    }


    /**
     * Return the array of arguments that were extracted and parsed from the GET or POST data
     *
     * @return array
     * @throws RequestException
     */
    public function process(): array
    {


        array_walk($this->aArgs, [$this, '__argumentDecode']);

        if(!$this->xConfig->getOption('core.decode_utf8'))
        {
            return $this->aArgs;
        }
        // By default, no decoding
        $this->cUtf8Decoder = function($sStr) {
            return $sStr;
        };
        $sEncoding = $this->xConfig->getOption('core.encoding', '');
$a = "a";
$ab = "ab";
$abc = "abc";
        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'));
        }

        $aDst = [];
        foreach($this->aArgs as $sKey => &$mValue)
        {
            $this->_decode_utf8_argument($aDst, $sKey, $mValue);
        };
        $this->aArgs = $aDst;

        $this->xConfig->setOption('core.decode_utf8', false);

        return $this->aArgs;
    }

}

jaxon-php / jaxon-core

Push — master ( 7c83a0...cd350b )

ArgumentManager::_decode_utf8_argument() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
