TypeAssertTrait - Code Metrics - Inspection of "Support for traversables in InclusionMatcher" - peridot-php/leo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#23)

by Erin

created 2016-06-10 07:14 UTC

TypeAssertTrait A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	282
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
wmc	24
c	3
b	0
f	0
lcom	1
cbo	0
dl	0
loc	282
rs	10

24 Methods

Rating	Name	Size	Complexity
A	typeOf()	5	1
A	notTypeOf()	5	1
A	isTrue()	5	1
A	isFalse()	5	1
A	isNull()	5	1
A	isNotNull()	5	1
A	isCallable()	5	1
A	isNotCallable()	5	1
A	isObject()	4	1
A	isNotObject()	4	1
A	isArray()	4	1
A	isNotArray()	4	1
A	isString()	4	1
A	isNotString()	4	1
A	isNumeric()	5	1
A	isNotNumeric()	5	1
A	isInteger()	4	1
A	isNotInteger()	4	1
A	isDouble()	4	1
A	isNotDouble()	4	1
A	isResource()	4	1
A	isNotResource()	4	1
A	isBoolean()	4	1
A	isNotBoolean()	4	1

<?php
namespace Peridot\Leo\Interfaces\Assert;

/**
 * TypeAssertTrait contains assertions that primarily deal
 * with making assertions about a value's type.
 *
 * @package Peridot\Leo\Interfaces\Assert
 */
trait TypeAssertTrait
{
    /**
     * Performs a type assertion.
     *
     * @param mixed $actual
     * @param string $expected
     * @param string $message
     */
    public function typeOf($actual, $expected, $message = "")
    {
        $this->assertion->setActual($actual);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        return $this->assertion->to->be->a($expected, $message);
    }

    /**
     * Performs a negated type assertion.
     *
     * @param mixed $actual
     * @param string $expected
     * @param string $message
     */
    public function notTypeOf($actual, $expected, $message = "")
    {
        $this->assertion->setActual($actual);
        return $this->assertion->to->not->be->a($expected, $message);
    }

    /**
     * Perform a true assertion.
     *
     * @param mixed $actual
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $message
     */
    public function isTrue($value, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->be->true($message);
    }

    /**
     * Perform a false assertion.
     *
     * @param mixed $value
     * @param string $message
     */
    public function isFalse($value, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->be->false($message);
    }

    /**
     * Perform a null assertion.
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNull($value, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->be->null($message);
    }

    /**
     * Perform a negated null assertion.
     *
     * @param mixed $actual
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $message
     */
    public function isNotNull($value, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->not->be->null($message);
    }

    /**
     * Performs a predicate assertion to check if actual
     * value is callable.
     *
     * @param mixed $value
     * @param string $message
     */
    public function isCallable($value, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->satisfy('is_callable', $message);
    }

    /**
     * Performs a negated predicate assertion to check if actual
     * value is not a callable.
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotCallable($value, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->not->satisfy('is_callable', $message);
    }

    /**
     * Perform a type assertion for type "object."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isObject($value, $message = "")
    {
        return $this->typeOf($value, 'object', $message);
    }

    /**
     * Perform a negative type assertion for type "object."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotObject($value, $message = "")
    {
        return $this->notTypeOf($value, 'object', $message);
    }

    /**
     * Perform a type assertion for type "array."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isArray($value, $message = "")
    {
        return $this->typeOf($value, 'array', $message);
    }

    /**
     * Performs a negative type assertion for type "array."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotArray($value, $message = "")
    {
        return $this->notTypeOf($value, 'array', $message);
    }

    /**
     * Perform a type assertion for type "string."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isString($value, $message = "")
    {
        return $this->typeOf($value, 'string', $message);
    }

    /**
     * Perform a negated type assertion for type "string."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotString($value, $message = "")
    {
        return $this->notTypeOf($value, 'string', $message);
    }

    /**
     * Performs a predicate assertion to check if actual
     * value is numeric.
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNumeric($value, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->satisfy('is_numeric', $message);
    }

    /**
     * Performs a negated predicate assertion to check if actual
     * value is numeric.
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotNumeric($value, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->not->to->satisfy('is_numeric', $message);
    }

    /**
     * Perform a type assertion for type "integer."
     *
     * @param $value
     * @param string $message
     */
    public function isInteger($value, $message = "")
    {
        return $this->typeOf($value, 'integer', $message);
    }

    /**
     * Perform a negated type assertion for type "integer."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotInteger($value, $message = "")
    {
        return $this->notTypeOf($value, 'integer', $message);
    }

    /**
     * Perform a type assertion for type "double."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isDouble($value, $message = "")
    {
        return $this->typeOf($value, 'double', $message);
    }

    /**
     * Perform a negated type assertion for type "double."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotDouble($value, $message = "")
    {
        return $this->notTypeOf($value, 'double', $message);
    }

    /**
     * Perform a type assertion for type "resource."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isResource($value, $message = "")
    {
        return $this->typeOf($value, 'resource', $message);
    }

    /**
     * Perform a negated type assertion for type "resource."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotResource($value, $message = "")
    {
        return $this->notTypeOf($value, 'resource', $message);
    }

    /**
     * Perform a type assertion for type "boolean."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isBoolean($value, $message = "")
    {
        return $this->typeOf($value, 'boolean', $message);
    }

    /**
     * Perform a negated type assertion for type "boolean."
     *
     * @param mixed $value
     * @param string $message
     */
    public function isNotBoolean($value, $message = "")
    {
        return $this->notTypeOf($value, 'boolean', $message);
    }
}


1			<?php
2			namespace Peridot\Leo\Interfaces\Assert;
3
4			/**
5			* TypeAssertTrait contains assertions that primarily deal
6			* with making assertions about a value's type.
7			*
8			* @package Peridot\Leo\Interfaces\Assert
9			*/
10			trait TypeAssertTrait
11			{
12			/**
13			* Performs a type assertion.
14			*
15			* @param mixed $actual
16			* @param string $expected
17			* @param string $message
18			*/
19			public function typeOf($actual, $expected, $message = "")
20			{
21			$this->assertion->setActual($actual);
			0 ignored issues – show Bug introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The property `assertion` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
22			return $this->assertion->to->be->a($expected, $message);
23			}
24
25			/**
26			* Performs a negated type assertion.
27			*
28			* @param mixed $actual
29			* @param string $expected
30			* @param string $message
31			*/
32			public function notTypeOf($actual, $expected, $message = "")
33			{
34			$this->assertion->setActual($actual);
35			return $this->assertion->to->not->be->a($expected, $message);
36			}
37
38			/**
39			* Perform a true assertion.
40			*
41			* @param mixed $actual
			0 ignored issues – show Bug introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report There is no parameter named `$actual`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
42			* @param string $message
43			*/
44			public function isTrue($value, $message = "")
45			{
46			$this->assertion->setActual($value);
47			return $this->assertion->to->be->true($message);
48			}
49
50			/**
51			* Perform a false assertion.
52			*
53			* @param mixed $value
54			* @param string $message
55			*/
56			public function isFalse($value, $message = "")
57			{
58			$this->assertion->setActual($value);
59			return $this->assertion->to->be->false($message);
60			}
61
62			/**
63			* Perform a null assertion.
64			*
65			* @param mixed $value
66			* @param string $message
67			*/
68			public function isNull($value, $message = "")
69			{
70			$this->assertion->setActual($value);
71			return $this->assertion->to->be->null($message);
72			}
73
74			/**
75			* Perform a negated null assertion.
76			*
77			* @param mixed $actual
			0 ignored issues – show Bug introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report There is no parameter named `$actual`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
78			* @param string $message
79			*/
80			public function isNotNull($value, $message = "")
81			{
82			$this->assertion->setActual($value);
83			return $this->assertion->to->not->be->null($message);
84			}
85
86			/**
87			* Performs a predicate assertion to check if actual
88			* value is callable.
89			*
90			* @param mixed $value
91			* @param string $message
92			*/
93			public function isCallable($value, $message = "")
94			{
95			$this->assertion->setActual($value);
96			return $this->assertion->to->satisfy('is_callable', $message);
97			}
98
99			/**
100			* Performs a negated predicate assertion to check if actual
101			* value is not a callable.
102			*
103			* @param mixed $value
104			* @param string $message
105			*/
106			public function isNotCallable($value, $message = "")
107			{
108			$this->assertion->setActual($value);
109			return $this->assertion->to->not->satisfy('is_callable', $message);
110			}
111
112			/**
113			* Perform a type assertion for type "object."
114			*
115			* @param mixed $value
116			* @param string $message
117			*/
118			public function isObject($value, $message = "")
119			{
120			return $this->typeOf($value, 'object', $message);
121			}
122
123			/**
124			* Perform a negative type assertion for type "object."
125			*
126			* @param mixed $value
127			* @param string $message
128			*/
129			public function isNotObject($value, $message = "")
130			{
131			return $this->notTypeOf($value, 'object', $message);
132			}
133
134			/**
135			* Perform a type assertion for type "array."
136			*
137			* @param mixed $value
138			* @param string $message
139			*/
140			public function isArray($value, $message = "")
141			{
142			return $this->typeOf($value, 'array', $message);
143			}
144
145			/**
146			* Performs a negative type assertion for type "array."
147			*
148			* @param mixed $value
149			* @param string $message
150			*/
151			public function isNotArray($value, $message = "")
152			{
153			return $this->notTypeOf($value, 'array', $message);
154			}
155
156			/**
157			* Perform a type assertion for type "string."
158			*
159			* @param mixed $value
160			* @param string $message
161			*/
162			public function isString($value, $message = "")
163			{
164			return $this->typeOf($value, 'string', $message);
165			}
166
167			/**
168			* Perform a negated type assertion for type "string."
169			*
170			* @param mixed $value
171			* @param string $message
172			*/
173			public function isNotString($value, $message = "")
174			{
175			return $this->notTypeOf($value, 'string', $message);
176			}
177
178			/**
179			* Performs a predicate assertion to check if actual
180			* value is numeric.
181			*
182			* @param mixed $value
183			* @param string $message
184			*/
185			public function isNumeric($value, $message = "")
186			{
187			$this->assertion->setActual($value);
188			return $this->assertion->to->satisfy('is_numeric', $message);
189			}
190
191			/**
192			* Performs a negated predicate assertion to check if actual
193			* value is numeric.
194			*
195			* @param mixed $value
196			* @param string $message
197			*/
198			public function isNotNumeric($value, $message = "")
199			{
200			$this->assertion->setActual($value);
201			return $this->assertion->not->to->satisfy('is_numeric', $message);
202			}
203
204			/**
205			* Perform a type assertion for type "integer."
206			*
207			* @param $value
208			* @param string $message
209			*/
210			public function isInteger($value, $message = "")
211			{
212			return $this->typeOf($value, 'integer', $message);
213			}
214
215			/**
216			* Perform a negated type assertion for type "integer."
217			*
218			* @param mixed $value
219			* @param string $message
220			*/
221			public function isNotInteger($value, $message = "")
222			{
223			return $this->notTypeOf($value, 'integer', $message);
224			}
225
226			/**
227			* Perform a type assertion for type "double."
228			*
229			* @param mixed $value
230			* @param string $message
231			*/
232			public function isDouble($value, $message = "")
233			{
234			return $this->typeOf($value, 'double', $message);
235			}
236
237			/**
238			* Perform a negated type assertion for type "double."
239			*
240			* @param mixed $value
241			* @param string $message
242			*/
243			public function isNotDouble($value, $message = "")
244			{
245			return $this->notTypeOf($value, 'double', $message);
246			}
247
248			/**
249			* Perform a type assertion for type "resource."
250			*
251			* @param mixed $value
252			* @param string $message
253			*/
254			public function isResource($value, $message = "")
255			{
256			return $this->typeOf($value, 'resource', $message);
257			}
258
259			/**
260			* Perform a negated type assertion for type "resource."
261			*
262			* @param mixed $value
263			* @param string $message
264			*/
265			public function isNotResource($value, $message = "")
266			{
267			return $this->notTypeOf($value, 'resource', $message);
268			}
269
270			/**
271			* Perform a type assertion for type "boolean."
272			*
273			* @param mixed $value
274			* @param string $message
275			*/
276			public function isBoolean($value, $message = "")
277			{
278			return $this->typeOf($value, 'boolean', $message);
279			}
280
281			/**
282			* Perform a negated type assertion for type "boolean."
283			*
284			* @param mixed $value
285			* @param string $message
286			*/
287			public function isNotBoolean($value, $message = "")
288			{
289			return $this->notTypeOf($value, 'boolean', $message);
290			}
291			}
292

peridot-php / leo

Pull Request — master (#23)

TypeAssertTrait A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

24 Methods

Duplication Side-by-Side

Filter issues like