Expectations - Code Metrics - Inspection of "PHP 7.0 - for now" - Dgame/php-expectation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6fa208...e9dd29 )

by Randy

created 2017-04-28 21:55 UTC

Expectations C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	444
Duplicated Lines	3.6 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

Metric	Value
wmc	57
lcom	1
cbo	0
dl	16
loc	444
rs	6.433
c	0
b	0
f	0

43 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	reject()	0	6	1
A	approveIf()	0	6	1
A	isApproved()	0	4	1
A	is()	0	4	1
A	isNot()	0	4	1
A	isInt()	0	4	1
A	isFloat()	0	4	1
A	isScalar()	0	4	1
A	isNumeric()	0	4	1
A	isString()	0	4	1
A	isBool()	0	4	1
A	isArray()	0	4	1
A	isObject()	0	4	1
A	isInstanceOf()	0	8	2
A	isCallable()	0	4	1
A	isDir()	0	4	1
A	isFile()	0	4	1
A	isEmpty()	0	4	1
A	isNotEmpty()	0	4	1
A	isNull()	0	4	1
A	isNotNull()	0	4	1
A	isTrue()	0	4	1
A	isFalse()	0	4	1
A	isEqual()	0	4	1
A	isNotEqual()	0	4	1
A	isIdenticalTo()	0	4	1
A	isNotIdenticalTo()	0	4	1
A	isBetween()	0	8	3
A	hasLength()	0	12	3
A	isIn()	0	4	1
A	isKeyOf()	0	4	1
A	isBelow()	0	8	2
A	isAbove()	0	8	2
A	isBelowOrEqual()	0	8	2
A	isAboveOrEqual()	0	8	2
A	isPositive()	0	4	1
A	isNegative()	0	4	1
A	isEven()	8	8	2
A	isOdd()	8	8	2
A	match()	0	8	2
A	then()	0	4	2
A	else()	0	4	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Expectations often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Expectations, and based on these observations, apply Extract Interface, too.

<?php

namespace Dgame\Expectation;

/**
 * Class Expectations
 * @package Dgame\Expectation
 */
final class Expectations
{
    /**
     * @var mixed
     */
    private $value;
    /**
     * @var bool
     */
    private $approved = true;

    /**
     * Expectations constructor.
     *
     * @param $value
     */
    public function __construct($value)
    {
        $this->value = $value;
    }

    /**
     * @return Expectations
     */
    private function reject(): self
    {
        $this->approved = false;

        return $this;
    }

    /**
     * @param bool $condition
     *
     * @return Expectations
     */
    private function approveIf(bool $condition): self
    {
        $this->approved = $condition;

        return $this;
    }

    /**
     * @return bool
     */
    public function isApproved(): bool
    {
        return $this->approved;
    }

    /**
     * @param callable $callback
     *
     * @return Expectations
     */
    public function is(callable $callback): self
    {
        return $this->approveIf($callback($this->value));
    }

    /**
     * @param callable $callback
     *
     * @return Expectations
     */
    public function isNot(callable $callback): self
    {
        return $this->approveIf(!$callback($this->value));
    }

    /**
     * @return Expectations
     */
    public function isInt(): self
    {
        return $this->is('is_int');
    }

    /**
     * @return Expectations
     */
    public function isFloat(): self
    {
        return $this->is('is_float');
    }

    /**
     * @return Expectations
     */
    public function isScalar(): self
    {
        return $this->is('is_scalar');
    }

    /**
     * @return Expectations
     */
    public function isNumeric(): self
    {
        return $this->is('is_numeric');
    }

    /**
     * @return Expectations
     */
    public function isString(): self
    {
        return $this->is('is_string');
    }

    /**
     * @return Expectations
     */
    public function isBool(): self
    {
        return $this->is('is_bool');
    }

    /**
     * @return Expectations
     */
    public function isArray(): self
    {
        return $this->is('is_array');
    }

    /**
     * @return Expectations
     */
    public function isObject(): self
    {
        return $this->is('is_object');
    }

    /**
     * @param $object
     *
     * @return Expectations
     */
    public function isInstanceOf($object): self
    {
        if ($this->isObject()->isApproved()) {
            return $this->approveIf($this->value instanceof $object);
        }

        return $this;
    }

    /**
     * @return Expectations
     */
    public function isCallable(): self
    {
        return $this->is('is_callable');
    }

    /**
     * @return Expectations
     */
    public function isDir(): self
    {
        return $this->is('is_dir');
    }

    /**
     * @return Expectations
     */
    public function isFile(): self
    {
        return $this->is('is_file');
    }

    /**
     * @return Expectations
     */
    public function isEmpty(): self
    {
        return $this->approveIf(empty($this->value));
    }

    /**
     * @return Expectations
     */
    public function isNotEmpty(): self
    {
        return $this->approveIf(!empty($this->value));
    }

    /**
     * @return Expectations
     */
    public function isNull(): self
    {
        return $this->isIdenticalTo(null);
    }

    /**
     * @return Expectations
     */
    public function isNotNull(): self
    {
        return $this->isNotIdenticalTo(null);
    }

    /**
     * @return Expectations
     */
    public function isTrue(): self
    {
        return $this->isIdenticalTo(true);
    }

    /**
     * @return Expectations
     */
    public function isFalse(): self
    {
        return $this->isIdenticalTo(false);
    }

    /**
     * @param $value
     *
     * @return Expectations
     */
    public function isEqual($value): self
    {
        return $this->approveIf($this->value == $value);
    }

    /**
     * @param $value
     *
     * @return Expectations
     */
    public function isNotEqual($value): self
    {
        return $this->approveIf($this->value != $value);
    }

    /**
     * @param $value
     *
     * @return Expectations
     */
    public function isIdenticalTo($value): self
    {
        return $this->approveIf($this->value === $value);
    }

    /**
     * @param $value
     *
     * @return Expectations
     */
    public function isNotIdenticalTo($value): self
    {
        return $this->approveIf($this->value !== $value);
    }

    /**
     * @param int $lhs
     * @param int $rhs
     *
     * @return Expectations
     */
    public function isBetween(int $lhs, int $rhs): self
    {
        if ($this->isNumeric()->isApproved()) {
            return $this->approveIf($this->value >= $lhs && $this->value <= $rhs);
        }

        return $this->reject();
    }

    /**
     * @param int $length
     *
     * @return Expectations
     */
    public function hasLength(int $length): self
    {
        if ($this->isString()->isApproved()) {
            return $this->approveIf(strlen($this->value) === $length);
        }

        if ($this->isArray()->isApproved()) {
            return $this->approveIf(count($this->value) === $length);
        }

        return $this->reject();
    }

    /**
     * @param array $values
     *
     * @return Expectations
     */
    public function isIn(array $values): self
    {
        return $this->approveIf(in_array($this->value, $values));
    }

    /**
     * @param array $values
     *
     * @return Expectations
     */
    public function isKeyOf(array $values): self
    {
        return $this->approveIf(array_key_exists($this->value, $values));
    }

    /**
     * @param int $value
     *
     * @return Expectations
     */
    public function isBelow(int $value): self
    {
        if ($this->isNumeric()->isApproved()) {
            return $this->approveIf($this->value < $value);
        }

        return $this->reject();
    }

    /**
     * @param int $value
     *
     * @return Expectations
     */
    public function isAbove(int $value): self
    {
        if ($this->isNumeric()->isApproved()) {
            return $this->approveIf($this->value > $value);
        }

        return $this->reject();
    }

    /**
     * @param int $value
     *
     * @return Expectations
     */
    public function isBelowOrEqual(int $value): self
    {
        if ($this->isNumeric()->isApproved()) {
            return $this->approveIf($this->value <= $value);
        }

        return $this->reject();
    }

    /**
     * @param int $value
     *
     * @return Expectations
     */
    public function isAboveOrEqual(int $value): self
    {
        if ($this->isNumeric()->isApproved()) {
            return $this->approveIf($this->value >= $value);
        }

        return $this->reject();
    }

    /**
     * @return Expectations
     */
    public function isPositive(): self
    {
        return $this->isAboveOrEqual(0);
    }

    /**
     * @return Expectations
     */
    public function isNegative(): self
    {
        return $this->isBelow(0);
    }

    /**
     * @return Expectations
     */
    public function isEven(): self

    {
        if ($this->isNumeric()->isApproved()) {
            return $this->approveIf(($this->value & 1) === 0);
        }

        return $this->reject();
    }

    /**
     * @return Expectations
     */
    public function isOdd(): self

    {
        if ($this->isNumeric()->isApproved()) {
            return $this->approveIf(($this->value & 1) === 1);
        }

        return $this->reject();
    }

    /**
     * @param string $pattern
     *
     * @return Expectations
     */
    public function match(string $pattern): self
    {
        if ($this->isString()->isApproved()) {
            return $this->approveIf(preg_match($pattern, $this->value) === 1);
        }

        return $this->reject();
    }

    /**
     * @param $value
     *
     * @return mixed
     */
    public function then($value)
    {
        return $this->isApproved() ? $value : $this->value;
    }

    /**
     * @param $default
     *
     * @return mixed
     */
    public function else($default)

    {
        return $this->isApproved() ? $this->value : $default;
    }
}

1		<?php
2
3		namespace Dgame\Expectation;
4
5		/**
6		* Class Expectations
7		* @package Dgame\Expectation
8		*/
9		final class Expectations
10		{
11		/**
12		* @var mixed
13		*/
14		private $value;
15		/**
16		* @var bool
17		*/
18		private $approved = true;
19
20		/**
21		* Expectations constructor.
22		*
23		* @param $value
24		*/
25		public function __construct($value)
26		{
27		$this->value = $value;
28		}
29
30		/**
31		* @return Expectations
32		*/
33		private function reject(): self
34		{
35		$this->approved = false;
36
37		return $this;
38		}
39
40		/**
41		* @param bool $condition
42		*
43		* @return Expectations
44		*/
45		private function approveIf(bool $condition): self
46		{
47		$this->approved = $condition;
48
49		return $this;
50		}
51
52		/**
53		* @return bool
54		*/
55		public function isApproved(): bool
56		{
57		return $this->approved;
58		}
59
60		/**
61		* @param callable $callback
62		*
63		* @return Expectations
64		*/
65		public function is(callable $callback): self
66		{
67		return $this->approveIf($callback($this->value));
68		}
69
70		/**
71		* @param callable $callback
72		*
73		* @return Expectations
74		*/
75		public function isNot(callable $callback): self
76		{
77		return $this->approveIf(!$callback($this->value));
78		}
79
80		/**
81		* @return Expectations
82		*/
83		public function isInt(): self
84		{
85		return $this->is('is_int');
86		}
87
88		/**
89		* @return Expectations
90		*/
91		public function isFloat(): self
92		{
93		return $this->is('is_float');
94		}
95
96		/**
97		* @return Expectations
98		*/
99		public function isScalar(): self
100		{
101		return $this->is('is_scalar');
102		}
103
104		/**
105		* @return Expectations
106		*/
107		public function isNumeric(): self
108		{
109		return $this->is('is_numeric');
110		}
111
112		/**
113		* @return Expectations
114		*/
115		public function isString(): self
116		{
117		return $this->is('is_string');
118		}
119
120		/**
121		* @return Expectations
122		*/
123		public function isBool(): self
124		{
125		return $this->is('is_bool');
126		}
127
128		/**
129		* @return Expectations
130		*/
131		public function isArray(): self
132		{
133		return $this->is('is_array');
134		}
135
136		/**
137		* @return Expectations
138		*/
139		public function isObject(): self
140		{
141		return $this->is('is_object');
142		}
143
144		/**
145		* @param $object
146		*
147		* @return Expectations
148		*/
149		public function isInstanceOf($object): self
150		{
151		if ($this->isObject()->isApproved()) {
152		return $this->approveIf($this->value instanceof $object);
153		}
154
155		return $this;
156		}
157
158		/**
159		* @return Expectations
160		*/
161		public function isCallable(): self
162		{
163		return $this->is('is_callable');
164		}
165
166		/**
167		* @return Expectations
168		*/
169		public function isDir(): self
170		{
171		return $this->is('is_dir');
172		}
173
174		/**
175		* @return Expectations
176		*/
177		public function isFile(): self
178		{
179		return $this->is('is_file');
180		}
181
182		/**
183		* @return Expectations
184		*/
185		public function isEmpty(): self
186		{
187		return $this->approveIf(empty($this->value));
188		}
189
190		/**
191		* @return Expectations
192		*/
193		public function isNotEmpty(): self
194		{
195		return $this->approveIf(!empty($this->value));
196		}
197
198		/**
199		* @return Expectations
200		*/
201		public function isNull(): self
202		{
203		return $this->isIdenticalTo(null);
204		}
205
206		/**
207		* @return Expectations
208		*/
209		public function isNotNull(): self
210		{
211		return $this->isNotIdenticalTo(null);
212		}
213
214		/**
215		* @return Expectations
216		*/
217		public function isTrue(): self
218		{
219		return $this->isIdenticalTo(true);
220		}
221
222		/**
223		* @return Expectations
224		*/
225		public function isFalse(): self
226		{
227		return $this->isIdenticalTo(false);
228		}
229
230		/**
231		* @param $value
232		*
233		* @return Expectations
234		*/
235		public function isEqual($value): self
236		{
237		return $this->approveIf($this->value == $value);
238		}
239
240		/**
241		* @param $value
242		*
243		* @return Expectations
244		*/
245		public function isNotEqual($value): self
246		{
247		return $this->approveIf($this->value != $value);
248		}
249
250		/**
251		* @param $value
252		*
253		* @return Expectations
254		*/
255		public function isIdenticalTo($value): self
256		{
257		return $this->approveIf($this->value === $value);
258		}
259
260		/**
261		* @param $value
262		*
263		* @return Expectations
264		*/
265		public function isNotIdenticalTo($value): self
266		{
267		return $this->approveIf($this->value !== $value);
268		}
269
270		/**
271		* @param int $lhs
272		* @param int $rhs
273		*
274		* @return Expectations
275		*/
276		public function isBetween(int $lhs, int $rhs): self
277		{
278		if ($this->isNumeric()->isApproved()) {
279		return $this->approveIf($this->value >= $lhs && $this->value <= $rhs);
280		}
281
282		return $this->reject();
283		}
284
285		/**
286		* @param int $length
287		*
288		* @return Expectations
289		*/
290		public function hasLength(int $length): self
291		{
292		if ($this->isString()->isApproved()) {
293		return $this->approveIf(strlen($this->value) === $length);
294		}
295
296		if ($this->isArray()->isApproved()) {
297		return $this->approveIf(count($this->value) === $length);
298		}
299
300		return $this->reject();
301		}
302
303		/**
304		* @param array $values
305		*
306		* @return Expectations
307		*/
308		public function isIn(array $values): self
309		{
310		return $this->approveIf(in_array($this->value, $values));
311		}
312
313		/**
314		* @param array $values
315		*
316		* @return Expectations
317		*/
318		public function isKeyOf(array $values): self
319		{
320		return $this->approveIf(array_key_exists($this->value, $values));
321		}
322
323		/**
324		* @param int $value
325		*
326		* @return Expectations
327		*/
328		public function isBelow(int $value): self
329		{
330		if ($this->isNumeric()->isApproved()) {
331		return $this->approveIf($this->value < $value);
332		}
333
334		return $this->reject();
335		}
336
337		/**
338		* @param int $value
339		*
340		* @return Expectations
341		*/
342		public function isAbove(int $value): self
343		{
344		if ($this->isNumeric()->isApproved()) {
345		return $this->approveIf($this->value > $value);
346		}
347
348		return $this->reject();
349		}
350
351		/**
352		* @param int $value
353		*
354		* @return Expectations
355		*/
356		public function isBelowOrEqual(int $value): self
357		{
358		if ($this->isNumeric()->isApproved()) {
359		return $this->approveIf($this->value <= $value);
360		}
361
362		return $this->reject();
363		}
364
365		/**
366		* @param int $value
367		*
368		* @return Expectations
369		*/
370		public function isAboveOrEqual(int $value): self
371		{
372		if ($this->isNumeric()->isApproved()) {
373		return $this->approveIf($this->value >= $value);
374		}
375
376		return $this->reject();
377		}
378
379		/**
380		* @return Expectations
381		*/
382		public function isPositive(): self
383		{
384		return $this->isAboveOrEqual(0);
385		}
386
387		/**
388		* @return Expectations
389		*/
390		public function isNegative(): self
391		{
392		return $this->isBelow(0);
393		}
394
395		/**
396		* @return Expectations
397		*/
398	View Code Duplication	public function isEven(): self
		0 ignored issues – show Duplication introduced 2017-04-28 21:50 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
399		{
400		if ($this->isNumeric()->isApproved()) {
401		return $this->approveIf(($this->value & 1) === 0);
402		}
403
404		return $this->reject();
405		}
406
407		/**
408		* @return Expectations
409		*/
410	View Code Duplication	public function isOdd(): self
		0 ignored issues – show Duplication introduced 2017-04-28 21:50 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
411		{
412		if ($this->isNumeric()->isApproved()) {
413		return $this->approveIf(($this->value & 1) === 1);
414		}
415
416		return $this->reject();
417		}
418
419		/**
420		* @param string $pattern
421		*
422		* @return Expectations
423		*/
424		public function match(string $pattern): self
425		{
426		if ($this->isString()->isApproved()) {
427		return $this->approveIf(preg_match($pattern, $this->value) === 1);
428		}
429
430		return $this->reject();
431		}
432
433		/**
434		* @param $value
435		*
436		* @return mixed
437		*/
438		public function then($value)
439		{
440		return $this->isApproved() ? $value : $this->value;
441		}
442
443		/**
444		* @param $default
445		*
446		* @return mixed
447		*/
448		public function else($default)
		0 ignored issues – show Coding Style introduced 2017-04-28 21:50 UTC by Report Bug Copy Issue Report Possible parse error: non-abstract method defined as abstract Loading history... Coding Style introduced 2017-04-28 21:50 UTC by Report Bug Copy Issue Report It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history...
449		{
450		return $this->isApproved() ? $this->value : $default;
451		}
452		}

Dgame / php-expectation