Argument::_decode_utf8_argument() - Code Metrics - Inspection of "Update Travis CI badge." - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 68b778...1b1614 )

by Thierry
created 2021-08-27 02:18 UTC
Argument::_decode_utf8_argument() B

↳ Parent: Argument
Complexity

Conditions	7
Paths	10
Size

Total Lines	24
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	11
c	1
b	0
f	0
dl	0
loc	24
rs	8.8333
cc	7
nc	10
nop	3
<?php

/**
 * Manager.php - Jaxon Request Manager
 *
 * 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\Exception\Error;

class Argument

{
    use \Jaxon\Features\Config;
    use \Jaxon\Features\Translator;

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

    /**
     * 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
     */
    public function __construct()

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

        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 integer
     */
    public function getRequestMethod()
    {
        return $this->nMethod;
    }


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

     *
     * @return boolean
     */
    private function __convertStringToBool($sValue)

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


    /**
     * Strip the slashes from a string
     *
     * @param string        $sArg                The string to be stripped
     *
     * @return string
     */
    // private function __argumentStripSlashes(&$sArg)
    // {
    //     if(!is_string($sArg))
    //     {
    //         return '';
    //     }
    //     $sArg = stripslashes($sArg);
    //     return $sArg;
    // }

    /**
     * Convert an Jaxon request argument to its value
     *
     * Depending of 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|boolean|integer|double|null
     */
    private function __convertValue($sValue)

    {
        $cType = \substr($sValue, 0, 1);
        $sValue = \substr($sValue, 1);
        switch($cType)
        {
        case 'S':
            $value = ($sValue === false ? '' : $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 string|null
     */
    private function __argumentDecode(&$sArg)

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

        // Arguments are url encoded when uploading files
        $sType = 'multipart/form-data';
$a = "a";
$ab = "ab";
$abc = "abc";
        $iLen = \strlen($sType);
$a = "a";
$ab = "ab";
$abc = "abc";
        $sContentType = '';
        if(\key_exists('CONTENT_TYPE', $_SERVER))
        {
            $sContentType = \substr($_SERVER['CONTENT_TYPE'], 0, $iLen);
        }
        elseif(\key_exists('HTTP_CONTENT_TYPE', $_SERVER))
        {
            $sContentType = \substr($_SERVER['HTTP_CONTENT_TYPE'], 0, $iLen);
        }
        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, $sKey, $mValue)

    {
        $sDestKey = $sKey;
        // Decode the key
        if(\is_string($sDestKey))

        {
            $sDestKey = \call_user_func($this->cUtf8Decoder, $sDestKey);
        }

        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
     */
    public function process()
    {
        // if(get_magic_quotes_gpc() == 1)
        // {
        //     \array_walk($this->aArgs, [$this, '__argumentStripSlashes']);
        // }
        \array_walk($this->aArgs, [$this, '__argumentDecode']);

        if(($this->getOption('core.decode_utf8')))
        {
            // By default, no decoding
            $this->cUtf8Decoder = function($sStr) {
                return $sStr;
            };
            if(\function_exists('iconv'))
            {
                $this->cUtf8Decoder = function($sStr) {
                    return \iconv("UTF-8", $this->getOption('core.encoding') . '//TRANSLIT', $sStr);
                };
            }
            elseif(\function_exists('mb_convert_encoding'))
            {
                $this->cUtf8Decoder = function($sStr) {
                    return \mb_convert_encoding($sStr, $this->getOption('core.encoding'), "UTF-8");
                };
            }
            elseif($this->getOption('core.encoding') == "ISO-8859-1")
            {
                $this->cUtf8Decoder = function($sStr) {
                    return \utf8_decode($sStr);
                };
            }
            else
            {
                throw new Error($this->trans('errors.request.conversion'));
            }

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

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

        return $this->aArgs;
    }

}

jaxon-php / jaxon-core

Push — master ( 68b778...1b1614 )

Argument::_decode_utf8_argument() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
