RestrictionUtils::checkWhiteSpace() - Code Metrics - Inspection of "Restriction Validation for Simple Types" - goetas-webservices/xsd-reader - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#11)

by Davidson

created 2016-10-26 13:19 UTC

RestrictionUtils::checkWhiteSpace() A

↳ Parent: RestrictionUtils

Complexity

Conditions	4
Paths	4

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	4

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	11
ccs	9
cts	9
cp	1
rs	9.2
cc	4
eloc	7
nc	4
nop	2
crap	4

<?php
namespace GoetasWebservices\XML\XSDReader\Utils;

use GoetasWebservices\XML\XSDReader\Exception\RestrictionException;

class RestrictionUtils
{

    /**
     * Defines a list of acceptable values.
     *  
     * @param mixed $value
     * @param array $enumeration
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkEnumeration($value, $enumeration)
    {
        if (!in_array($value, $enumeration)) {
            $values = implode(', ', $enumeration);
            throw new RestrictionException(
                    "The restriction enumeration with '$values' is not true", 
                    RestrictionException::ERROR_CODE_ENUMARATION,
                    $value,
                    $enumeration);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }   
        return $value;
    }
    
    /**
     * Defines the exact sequence of characters that are acceptable.
     * 
     * @param mixed $value
     * @param string $pattern
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkPattern($value, $pattern)
    {
        if (!preg_match("/^{$pattern}$/", $value)) {
            throw new RestrictionException(
                    "The restriction pattern with '$pattern' is not true", 
                    RestrictionException::ERROR_CODE_PATTERN,
                    $value,
                    $pattern);
        }
        return $value;
    }
    
    /**
     * Check is numeric valid
     * 
     * @param mixed $value
     * @return mixed
     * @throws RestrictionException
     */
    private static function getNumeric($value) 
    {
        if (!is_numeric($value)) {
            throw new RestrictionException(
                    "The '$value' is not a valid numeric", 
                    RestrictionException::ERROR_CODE_VALUE,
                    $value,
                    'is_numeric');
        }
        return $value + 0;
    }
    
    /**
     * Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero.
     * 
     * @param float $value
     * @param int $fractionDigits
     * @throws RestrictionException
     * @return float
     */
    public static function checkFractionDigits($value, $fractionDigits) 
    {
        $numeric = static::getNumeric($value);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        if ($numeric < 0) {
            throw new RestrictionException(
                    "The '$numeric' must be equal to or greater than zero", 
                    RestrictionException::ERROR_CODE_GTE,
                    $numeric);
        }
        $count = 0;
        if ((int)$numeric != $numeric){
            $count = strlen($numeric) - strrpos($numeric, '.') - 1;
        }
        if ($count > $fractionDigits) {
            throw new RestrictionException(
                    "The restriction fraction digits with '$fractionDigits' is not true", 
                    RestrictionException::ERROR_CODE_FRACTION_DIGITS,
                    $value,
                    $fractionDigits);
        }
        return $numeric;
    }
    
    /**
     * Specifies the exact number of digits allowed. Must be greater than zero.
     * 
     * @param float $value
     * @param int $totalDigits
     * @throws RestrictionException
     * @return float
     */
    public static function checkTotalDigits($value, $totalDigits) 
    {
        $numeric = static::getNumeric($value);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        if ($numeric < 0) {
            throw new RestrictionException(
                    "The '$numeric' must be equal to or greater than zero", 
                    RestrictionException::ERROR_CODE_GTE,
                    $numeric);
        }
        $count = 0;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        if ($numeric === 0) {
            $count = 1;
        } else {
            $count = floor(log10(floor($numeric))) + 1;
        }
        
        if ($count > $totalDigits) {
            throw new RestrictionException(
                    "The restriction total digits with '$totalDigits' is not true", 
                    RestrictionException::ERROR_CODE_TOTAL_DIGITS,
                    $value,
                    $totalDigits);
        }
        return $numeric;
    }
    
    /**
     * Specifies the upper bounds for numeric values (the value must be less than this value)
     * 
     * @param mixed $value
     * @param int $maxExclusive
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkMaxExclusive($value, $maxExclusive) 

    {
        $numeric = static::getNumeric($value);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        if ($numeric >= $maxExclusive) {
            throw new RestrictionException(
                    "The restriction max exclusive with '$maxExclusive' is not true", 
                    RestrictionException::ERROR_CODE_MAX_EXCLUSIVE,
                    $value,
                    $maxExclusive);
        }
        return $numeric;
    }
    
    /**
     * Specifies the upper bounds for numeric values (the value must be less than or equal to this value)
     * 
     * @param mixed $value
     * @param int $maxInclusive
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkMaxInclusive($value, $maxInclusive) 

    {
        $numeric = static::getNumeric($value);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        if ($numeric > $maxInclusive) {
            throw new RestrictionException(
                    "The restriction max inclusive with '$maxInclusive' is not true", 
                    RestrictionException::ERROR_CODE_MAX_INCLUSIVE,
                    $value,
                    $maxInclusive);
        }
        return $numeric;
    }
    
    /**
     * Retrive the number of characters or list items allowed. 
     * 
     * @param mixed $value
     * @param string $nativeType
     * @throws RestrictionException
     * @return int
     */
    private static function getLength($value, $nativeType=null) 
    {
        $valueLength = 0;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        if (in_array($nativeType, ['int','float','integer']) && is_numeric($value)) {
            $valueLength = static::getNumeric($value);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        } else
        if (is_array($value)) {
            $valueLength = count($value);
        } else {
            $valueLength = strlen($value);
        }
        if ($valueLength < 0) {
            throw new RestrictionException(
                    "The '$value' must be equal to or greater than zero", 
                    RestrictionException::ERROR_CODE_GTE,
                    $value);
        }
        return $valueLength;
    }    
    
    /**
     * Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero.
     * 
     * @param mixed $value
     * @param int $length
     * @param string $nativeType
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkLength($value, $length, $nativeType=null) 

    {
        if (static::getLength($value, $nativeType) != $length) {
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            throw new RestrictionException(
                    "The restriction length with '$length' is not true", 
                    RestrictionException::ERROR_CODE_LENGTH,
                    $value,
                    $length);
        }
        return $value;
    }    
    
    /**
     * Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero
     * 
     * @param mixed $value
     * @param int $maxLength
     * @param string $nativeType
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkMaxLength($value, $maxLength, $nativeType=null) 

    {
        if (static::getLength($value, $nativeType) > $maxLength) {
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            throw new RestrictionException(
                    "The restriction max length with '$maxLength' is not true", 
                    RestrictionException::ERROR_CODE_MAX_LENGTH,
                    $value,
                    $maxLength);
        }
        return $value;
    }
    
    /**
     * Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero
     * 
     * @param mixed $value
     * @param int $minLength
     * @param string $nativeType
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkMinLength($value, $minLength, $nativeType=null) 

    {
        if (static::getLength($value, $nativeType) < $minLength) {
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            throw new RestrictionException(
                    "The restriction min length with '$minLength' is not true", 
                    RestrictionException::ERROR_CODE_MIN_LENGTH,
                    $value,
                    $minLength);
        }
        return $value;
    }
    
    /**
     * Specifies the lower bounds for numeric values (the value must be greater than this value)
     * 
     * @param mixed $value
     * @param int $minExclusive
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkMinExclusive($value, $minExclusive) 

    {
        $numeric = static::getNumeric($value);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        if ($numeric <= $minExclusive) {
            throw new RestrictionException(
                    "The restriction min exclusive with '$minExclusive' is not true", 
                    RestrictionException::ERROR_CODE_MIN_EXCLUSIVE,
                    $value,
                    $minExclusive);
        }
        return $numeric;
    }
    
    /**
     * Specifies the lower bounds for numeric values (the value must be greater than or equal to this value)
     * 
     * @param mixed $value
     * @param int $minInclusive
     * @throws RestrictionException
     * @return mixed
     */
    public static function checkMinInclusive($value, $minInclusive) 

    {
        $numeric = static::getNumeric($value);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        if ($numeric < $minInclusive) {
            throw new RestrictionException(
                    "The restriction min inclusive with '$minInclusive' is not true", 
                    RestrictionException::ERROR_CODE_MIN_INCLUSIVE,
                    $value,
                    $minInclusive);
        }
        return $numeric;
    }

    /**
     * Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled
     * 
     * @param mixed $value
     * @param string $whiteSpace
     * @return mixed
     */
    public static function checkWhiteSpace($value, $whiteSpace) 
    {
        $output = $value;
        if ($whiteSpace == 'replace' || $whiteSpace == 'collapse') {
            $output = preg_replace('/\s/', ' ', $output);
        }
        if ($whiteSpace == 'collapse') {
            $output = preg_replace('/\s+/', ' ', $output);
        }
        return $output;
    }	

}


1		<?php
2		namespace GoetasWebservices\XML\XSDReader\Utils;
3
4		use GoetasWebservices\XML\XSDReader\Exception\RestrictionException;
5
6		class RestrictionUtils
7		{
8
9		/**
10		* Defines a list of acceptable values.
11		*
12		* @param mixed $value
13		* @param array $enumeration
14		* @throws RestrictionException
15		* @return mixed
16		*/
17	2	public static function checkEnumeration($value, $enumeration)
18		{
19	2	if (!in_array($value, $enumeration)) {
20	1	$values = implode(', ', $enumeration);
21	1	throw new RestrictionException(
22	1	"The restriction enumeration with '$values' is not true",
23	1	RestrictionException::ERROR_CODE_ENUMARATION,
24	1	$value,
25	1	$enumeration);
		0 ignored issues – show Documentation introduced 2016-10-26 13:22 UTC by Report Bug Copy Issue Report `$enumeration` is of type `array`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
26		}
27	1	return $value;
28		}
29
30		/**
31		* Defines the exact sequence of characters that are acceptable.
32		*
33		* @param mixed $value
34		* @param string $pattern
35		* @throws RestrictionException
36		* @return mixed
37		*/
38	2	public static function checkPattern($value, $pattern)
39		{

goetas-webservices / xsd-reader

Pull Request — master (#11)

RestrictionUtils::checkWhiteSpace() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like