ArrayValidator::unique() - Code Metrics - Inspection of "Merge pull request #14 from mrferos/feature/array-..." - mrferos/comfort - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3b4efc...fefeeb )

by Andres

created 2016-05-16 13:08 UTC

ArrayValidator::unique() A

↳ Parent: ArrayValidator

Complexity

Conditions	2
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	2
eloc	4
c	1
b	0
f	1
nc	1
nop	0
dl	0
loc	8
rs	9.4285

<?php
namespace Comfort\Validator;

use Comfort\Comfort;
use Comfort\Error;
use Comfort\Exception\ValidationException;
use Comfort\ValidationError;

class ArrayValidator extends AbstractValidator
{
    /**
     * ArrayValidator constructor.
     * @param Comfort $comfort
     */
    public function __construct(Comfort $comfort)
    {
        parent::__construct($comfort);

        $this->toBool(false);
    }

    /**
     * Given a set of keys apply the specified validation rules
     *
     * @param array $definition
     * @return $this
     */
    public function keys(array $definition)
    {
        return $this->add(function(&$value) use ($definition) {
            /**
             * @var string $key
             * @var AbstractValidator $validator
             */
            foreach ($definition as $key => $validator) {
                $validator->toBool(false);
                $validatorValue = isset($value[$key]) ? $value[$key] : null;
                $result = $validator($validatorValue, $key);
                if ($result instanceof ValidationError) {
                    throw new ValidationException($result->getKey(), $result->getMessage());
                }

                if (isset($value[$key])) {
                    $value[$key] = $result;
                }
            }

            return $value;
        });
    }

    /**
     * Validate array has more than $min elements
     *
     * @param $min
     * @return $this
     */
    public function min($min)
    {
        return $this->add(function($value, $nameKey) use($min) {
            if (count($value) < $min) {
                return $this->createError('array.min', $value, $nameKey);
            }
        });
    }

    /**
     * Validate array has only up to $max characters
     *
     * @param $max
     * @return $this
     */
    public function max($max)
    {
        return $this->add(function($value, $nameKey) use($max) {
            if (count($value) > $max) {
                return $this->createError('array.max', $value, $nameKey);
            }
        });
    }

    /**
     * Validate array contains exactly $length elements
     *
     * @param $length
     * @return $this
     */
    public function length($length)
    {
        return $this->add(function($value, $nameKey) use($length) {
            if (count($value) != $length) {
                return $this->createError('array.length', $value, $nameKey);
            }
        });
    }

    /**
     * Validate array is unique
     *
     * @return $this
     */
    public function unique()
    {
        return $this->add(function($value, $nameKey) {
            if (md5(serialize($value)) != md5(serialize(array_unique($value)))) {
                return $this->createError('array.unique', $value, $nameKey);
            }
        });
    }

    /**
     * Apply $definition to individual items in the array,
     * used in case of multi-dimensional array
     *
     * @param AbstractValidator $definition
     * @return $this
     */
    public function items(AbstractValidator $definition)
    {
        return $this->add(function($value, $nameKey) use($definition) {
            if (!is_array($value)) {
                return $this->createError('array.items.not_array', $value, $nameKey);
            }

            foreach ($value as $key => $val) {
                $resp = $definition($val, $nameKey);
                if ($resp instanceof ValidationError) {
                    return $this->createError(
                        'array.items.validation_failure', $value, $nameKey
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    );
                }
            }
        });

        return $this;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
    }
}

1			<?php
2			namespace Comfort\Validator;
3
4			use Comfort\Comfort;
5			use Comfort\Error;
6			use Comfort\Exception\ValidationException;
7			use Comfort\ValidationError;
8
9			class ArrayValidator extends AbstractValidator
10			{
11			/**
12			* ArrayValidator constructor.
13			* @param Comfort $comfort
14			*/
15			public function __construct(Comfort $comfort)
16			{
17			parent::__construct($comfort);
18
19			$this->toBool(false);
20			}
21
22			/**
23			* Given a set of keys apply the specified validation rules
24			*
25			* @param array $definition
26			* @return $this
27			*/
28			public function keys(array $definition)
29			{
30			return $this->add(function(&$value) use ($definition) {
31			/**
32			* @var string $key
33			* @var AbstractValidator $validator
34			*/
35			foreach ($definition as $key => $validator) {
36			$validator->toBool(false);
37			$validatorValue = isset($value[$key]) ? $value[$key] : null;
38			$result = $validator($validatorValue, $key);
39			if ($result instanceof ValidationError) {
40			throw new ValidationException($result->getKey(), $result->getMessage());
41			}
42
43			if (isset($value[$key])) {
44			$value[$key] = $result;
45			}
46			}
47
48			return $value;
49			});
50			}
51
52			/**
53			* Validate array has more than $min elements
54			*
55			* @param $min
56			* @return $this
57			*/
58			public function min($min)
59			{
60			return $this->add(function($value, $nameKey) use($min) {
61			if (count($value) < $min) {
62			return $this->createError('array.min', $value, $nameKey);
63			}
64			});
65			}
66
67			/**
68			* Validate array has only up to $max characters
69			*
70			* @param $max
71			* @return $this
72			*/
73			public function max($max)
74			{
75			return $this->add(function($value, $nameKey) use($max) {
76			if (count($value) > $max) {
77			return $this->createError('array.max', $value, $nameKey);
78			}
79			});
80			}
81
82			/**
83			* Validate array contains exactly $length elements
84			*
85			* @param $length
86			* @return $this
87			*/
88			public function length($length)
89			{
90			return $this->add(function($value, $nameKey) use($length) {
91			if (count($value) != $length) {
92			return $this->createError('array.length', $value, $nameKey);
93			}
94			});
95			}
96
97			/**
98			* Validate array is unique
99			*
100			* @return $this
101			*/
102			public function unique()
103			{
104			return $this->add(function($value, $nameKey) {
105			if (md5(serialize($value)) != md5(serialize(array_unique($value)))) {
106			return $this->createError('array.unique', $value, $nameKey);
107			}
108			});
109			}
110
111			/**
112			* Apply $definition to individual items in the array,
113			* used in case of multi-dimensional array
114			*
115			* @param AbstractValidator $definition
116			* @return $this
117			*/
118			public function items(AbstractValidator $definition)
119			{
120			return $this->add(function($value, $nameKey) use($definition) {
121			if (!is_array($value)) {
122			return $this->createError('array.items.not_array', $value, $nameKey);
123			}
124
125			foreach ($value as $key => $val) {
126			$resp = $definition($val, $nameKey);
127			if ($resp instanceof ValidationError) {
128			return $this->createError(
129			'array.items.validation_failure', $value, $nameKey
			0 ignored issues – show Documentation introduced 2016-05-16 12:17 UTC by Report Bug Copy Issue Report `$value` is of type `array`, but the function expects a `null\|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...
130			);
131			}
132			}
133			});
134
135			return $this;
			0 ignored issues – show Unused Code introduced 2016-05-16 12:17 UTC by Report Bug Copy Issue Report `return $this;` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
136			}
137			}

mrferos / comfort

Push — master ( 3b4efc...fefeeb )

ArrayValidator::unique() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like