Validator::assertIsArray() - Code Metrics - Inspection of "Merge pull request #130 from MarcinOrlowski/dev" - MarcinOrlowski/laravel-api-response-builder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 724ebd...bb6c14 )

by Marcin

created 2019-11-22 16:08 UTC

Validator::assertIsArray() A

↳ Parent: Validator

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	2
dl	0
loc	3
ccs	0
cts	0
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php
declare(strict_types=1);

namespace MarcinOrlowski\ResponseBuilder;

/**
 * Laravel API Response Builder
 *
 * @package   MarcinOrlowski\ResponseBuilder
 *
 * @author    Marcin Orlowski <mail (#) marcinOrlowski (.) com>
 * @copyright 2016-2019 Marcin Orlowski
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      https://github.com/MarcinOrlowski/laravel-api-response-builder
 */
class Validator
{
    /** @var string */
    public const TYPE_STRING = 'string';

    /** @var string */
    public const TYPE_INTEGER = 'integer';

    /** @var string */
    public const TYPE_BOOL = 'boolean';

    /** @var string */
    public const TYPE_ARRAY = 'array';

    /** @var string */
    public const TYPE_OBJECT = 'object';

    /** @var string */
    public const TYPE_NULL = 'NULL';

    /**
     * Checks if given $val is of type boolean
     *
     * @param string $key Name of the key to be used if exception is thrown.
     * @param mixed  $var Variable to be asserted.
     *
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public static function assertIsBool(string $key, $var): void
    {
        self::assertIsType($key, $var, [self::TYPE_BOOL]);
    }

    /**
     * Checks if given $val is of type integer
     *
     * @param string $key Name of the key to be used if exception is thrown.
     * @param mixed  $var Variable to be asserted.
     *
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public static function assertIsInt(string $key, $var): void
    {
        self::assertIsType($key, $var, [self::TYPE_INTEGER]);
    }

    /**
     * Checks if given $val is of type array
     *
     * @param string $key Name of the key to be used if exception is thrown.
     * @param mixed  $var Variable to be asserted.
     *
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public static function assertIsArray(string $key, $var): void
    {
        self::assertIsType($key, $var, [self::TYPE_ARRAY]);
    }

    /**
     * Checks if given $val is an object
     *
     * @param string $key Name of the key to be used if exception is thrown.
     * @param mixed  $var Variable to be asserted.
     *
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public static function assertIsObject(string $key, $var): void
    {
        self::assertIsType($key, $var, [self::TYPE_OBJECT]);
    }

    /**
     * Checks if given $val is of type string
     *
     * @param string $name Label or name of the variable to be used in exception message (if thrown).
     * @param mixed  $var  Variable to be asserted.
     *
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public static function assertIsString(string $name, $var): void
    {
        self::assertIsType($name, $var, [self::TYPE_STRING]);
    }

    /**
     * @param string $name Label or name of the variable to be used in exception message (if thrown).
     * @param mixed  $var  Variable to be asserted.
     * @param int    $min  Min allowed value (inclusive)
     * @param int    $max  Max allowed value (inclusive)
     *
     * @return void
     *
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     */
    public static function assertIsIntRange(string $name, $var, int $min, int $max): void
    {
        self::assertIsInt($name, $var);

        if ($min > $max) {
            throw new \RuntimeException(
                sprintf('%s: Invalid range for "%s". Ensure bound values are not swapped.', __FUNCTION__, $name));
        }

        if (($min > $var) || ($var > $max)) {
            throw new \InvalidArgumentException(
                sprintf('Invalid value of "%s" (%d). Must be between %d-%d inclusive.', $name, $var, $min, $max));
        }
    }

    /**
     * Checks if $item (of name $key) is of type that is include in $allowed_types.
     *
     * @param string $name          Label or name of the variable to be used in exception message (if thrown).
     * @param mixed  $var           Variable to be asserted.
     * @param array  $allowed_types Array of allowed types for $var, i.e. [Validator::TYPE_INTEGER]
     *
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public static function assertIsType(string $name, $var, array $allowed_types): void
    {
        $type = gettype($var);
        if (!in_array($type, $allowed_types)) {
            throw new \InvalidArgumentException(
                sprintf('"%s" must be one of allowed types: %s (%s given)',
                    $name, implode(', ', $allowed_types), gettype($var))
            );
        }
    }

    /**
     * Ensures given $http_code is valid code for error response.
     *
     * @param int $http_code
     */
    public static function assertErrorHttpCode(int $http_code): void
    {
        self::assertIsInt('http_code', $http_code);
        self::assertIsIntRange('http_code', $http_code,
            ResponseBuilder::ERROR_HTTP_CODE_MIN, ResponseBuilder::ERROR_HTTP_CODE_MAX);
    }

    /**
     * Ensures given $http_code is valid for response indicating sucessful operation.
     *
     * @param int $http_code
     */
    public static function assertOkHttpCode(int $http_code): void
    {
        self::assertIsInt('http_code', $http_code);
        self::assertIsIntRange('http_code', $http_code, 200, 299);
    }

    /**
     * Ensures $obj is instance of $cls.
     *
     * @param string $name
     * @param object $obj
     * @param string $cls
     */
    public static function assertInstanceOf(string $name, object $obj, string $cls): void
    {
        if (!($obj instanceof $cls)) {
            throw new \InvalidArgumentException(
                sprintf('"%s" must be instance of "%s".', $name, $cls)
            );
        }
    }
}


1		<?php
2		declare(strict_types=1);
3
4		namespace MarcinOrlowski\ResponseBuilder;
5
6		/**
7		* Laravel API Response Builder
8		*
9		* @package MarcinOrlowski\ResponseBuilder
10		*
11		* @author Marcin Orlowski <mail (#) marcinOrlowski (.) com>
12		* @copyright 2016-2019 Marcin Orlowski
13		* @license http://www.opensource.org/licenses/mit-license.php MIT
14		* @link https://github.com/MarcinOrlowski/laravel-api-response-builder
15		*/
16		class Validator
17		{
18		/** @var string */
19		public const TYPE_STRING = 'string';
20
21		/** @var string */
22		public const TYPE_INTEGER = 'integer';
23
24		/** @var string */
25		public const TYPE_BOOL = 'boolean';
26
27		/** @var string */
28	44	public const TYPE_ARRAY = 'array';
29
30	44	/** @var string */
31	3	public const TYPE_OBJECT = 'object';
32	3
33		/** @var string */
34	41	public const TYPE_NULL = 'NULL';
35
36		/**
37		* Checks if given $val is of type boolean
38		*
39		* @param string $key Name of the key to be used if exception is thrown.
40		* @param mixed $var Variable to be asserted.
41		*
42		* @return void
43		*
44		* @throws \InvalidArgumentException
45		*/
46		public static function assertIsBool(string $key, $var): void
47	35	{
48		self::assertIsType($key, $var, [self::TYPE_BOOL]);
49	35	}
50
51	34	/**
52	1	* Checks if given $val is of type integer
53	1	*
54		* @param string $key Name of the key to be used if exception is thrown.
55		* @param mixed $var Variable to be asserted.
56	33	*
57	4	* @return void
58	4	*
59		* @throws \InvalidArgumentException
60	30	*/
61		public static function assertIsInt(string $key, $var): void
62		{
63		self::assertIsType($key, $var, [self::TYPE_INTEGER]);
64		}
65
66		/**
67		* Checks if given $val is of type array
68		*
69		* @param string $key Name of the key to be used if exception is thrown.
70		* @param mixed $var Variable to be asserted.
71		*
72		* @return void
73		*
74		* @throws \InvalidArgumentException
75		*/
76		public static function assertIsArray(string $key, $var): void
77		{
78		self::assertIsType($key, $var, [self::TYPE_ARRAY]);
79		}
80
81		/**
82		* Checks if given $val is an object
83		*
84		* @param string $key Name of the key to be used if exception is thrown.
85		* @param mixed $var Variable to be asserted.
86		*
87		* @return void
88		*
89		* @throws \InvalidArgumentException
90		*/
91		public static function assertIsObject(string $key, $var): void
92		{
93		self::assertIsType($key, $var, [self::TYPE_OBJECT]);
94		}
95
96		/**
97		* Checks if given $val is of type string
98		*
99		* @param string $name Label or name of the variable to be used in exception message (if thrown).
100		* @param mixed $var Variable to be asserted.
101		*
102		* @return void
103		*
104		* @throws \InvalidArgumentException
105		*/
106		public static function assertIsString(string $name, $var): void
107		{
108		self::assertIsType($name, $var, [self::TYPE_STRING]);
109		}
110
111		/**
112		* @param string $name Label or name of the variable to be used in exception message (if thrown).
113		* @param mixed $var Variable to be asserted.
114		* @param int $min Min allowed value (inclusive)
115		* @param int $max Max allowed value (inclusive)
116		*
117		* @return void
118		*
119		* @throws \InvalidArgumentException
120		* @throws \RuntimeException
121		*/
122		public static function assertIsIntRange(string $name, $var, int $min, int $max): void
123		{
124		self::assertIsInt($name, $var);
125
126		if ($min > $max) {
127		throw new \RuntimeException(
128		sprintf('%s: Invalid range for "%s". Ensure bound values are not swapped.', __FUNCTION__, $name));
129		}
130
131		if (($min > $var) \|\| ($var > $max)) {
132		throw new \InvalidArgumentException(
133		sprintf('Invalid value of "%s" (%d). Must be between %d-%d inclusive.', $name, $var, $min, $max));
134		}
135		}
136
137		/**
138		* Checks if $item (of name $key) is of type that is include in $allowed_types.
139		*
140		* @param string $name Label or name of the variable to be used in exception message (if thrown).
141		* @param mixed $var Variable to be asserted.
142		* @param array $allowed_types Array of allowed types for $var, i.e. [Validator::TYPE_INTEGER]
143		*
144		* @return void
145		*
146		* @throws \InvalidArgumentException
147		*/
148		public static function assertIsType(string $name, $var, array $allowed_types): void
149		{
150		$type = gettype($var);
151		if (!in_array($type, $allowed_types)) {
152		throw new \InvalidArgumentException(
153		sprintf('"%s" must be one of allowed types: %s (%s given)',
154		$name, implode(', ', $allowed_types), gettype($var))
155		);
156		}
157		}
158
159		/**
160		* Ensures given $http_code is valid code for error response.
161		*
162		* @param int $http_code
163		*/
164		public static function assertErrorHttpCode(int $http_code): void
165		{
166		self::assertIsInt('http_code', $http_code);
167		self::assertIsIntRange('http_code', $http_code,
168		ResponseBuilder::ERROR_HTTP_CODE_MIN, ResponseBuilder::ERROR_HTTP_CODE_MAX);
169		}
170
171		/**
172		* Ensures given $http_code is valid for response indicating sucessful operation.
173		*
174		* @param int $http_code
175		*/
176		public static function assertOkHttpCode(int $http_code): void
177		{
178		self::assertIsInt('http_code', $http_code);
179		self::assertIsIntRange('http_code', $http_code, 200, 299);
180		}
181
182		/**
183		* Ensures $obj is instance of $cls.
184		*
185		* @param string $name
186		* @param object $obj
187		* @param string $cls
188		*/
189		public static function assertInstanceOf(string $name, object $obj, string $cls): void
190		{
191		if (!($obj instanceof $cls)) {
192		throw new \InvalidArgumentException(
193		sprintf('"%s" must be instance of "%s".', $name, $cls)
194		);
195		}
196		}
197		}
198

MarcinOrlowski / laravel-api-response-builder

Push — master ( 724ebd...bb6c14 )

Validator::assertIsArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like