StaticValidator::validates() - Code Metrics - slickframework/validator - Measure and Improve Code Quality continuously with Scrutinizer

StaticValidator::validates() A
last analyzed 2016-02-02 17:27 UTC

↳ Parent: StaticValidator

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	8
ccs	5
cts	5
cp	1
rs	9.4285
cc	1
eloc	5
nc	1
nop	3
crap	1

<?php

/**
 * This file is part of slick/validator package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Validator;

use Slick\Validator\Exception\InvalidArgumentException;

/**
 * Static Validator
 *
 * @package Slick\Validator
 * @author  Filipe Silva <[email protected]>
 */
final class StaticValidator
{

    /**
     * @var array List of available validators
     */
    public static $validators = [
        'notEmpty'     => 'Slick\Validator\NotEmpty',
        'email'        => 'Slick\Validator\Email',
        'alphaNumeric' => 'Slick\Validator\AlphaNumeric',
        'number'       => 'Slick\Validator\Number',
        'url'          => 'Slick\Validator\Url'
    ];

    /**
     * @var array The error messages from last validation
     */
    protected static $messages = [];

    /**
     * @var string
     */
    protected static $message = '';

    /**
     * Returns true if and only if $value meets the validation requirements
     *
     * @param string $validator The validator name
     * @param mixed $value
     *
     * @throws Exception\UnknownValidatorClassException
     * @return bool
     *
     * @deprecated Should use the validates instead
     *
     * @see Slick\Validator\StaticValidator::$validators
     */
    public static function isValid($validator, $value)
    {
        /** @var ValidatorInterface $validator */
        $validator = static::create($validator);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $result = $validator->validates($value);
        static::$messages[] = $validator->getMessage();
        return $result;
    }

    /**
     * Returns true if and only if $value meets the validation requirements
     *
     * The context specified can be used in the validation process so that
     * the same value can be valid or invalid depending on that data.
     *
     * @param string $validator
     * @param mixed $value
     * @param array|mixed $context
     *
     * @return bool
     */
    public static function validates($validator, $value, $context = [])
    {
        /** @var ValidatorInterface $validator */
        $validator = static::create($validator);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $result = $validator->validates($value, $context);
        static::$message = $validator->getMessage();

        return $result;
    }

    /**
     * Creates a validator object
     *
     * @param string $validator The validator class name or alias
     *
     * @param null $message
     * @throws Exception\UnknownValidatorClassException
     *
     * @return ValidatorInterface
     *
     */
    public static function create($validator, $message = null)
    {
        $class = self::checkValidator($validator);

        /** @var ValidatorInterface $object */
        $object = new $class;
        if (!is_null($message)) {
            $object->setMessage($message);
        }
        return $object;
    }

    /**
     * Returns an array of messages that explain why the most recent
     * isValid() call returned false. The array keys are validation failure
     * message identifiers, and the array values are the corresponding
     * human-readable message strings.
     *
     * @deprecated  You should use instead the StaticValidator::getMessage()
     *
     * @return array
     */
    public static function geMessages()
    {
        return static::$messages;
    }

    /**
     * Returns the message that explain why the most recent
     * validates() call returned false.
     *
     * @return array
     */
    public static function geMessage()
    {
        return static::$message;
    }

    /**
     * Check if the provided validator is a known alias or a valid validator
     * interface class
     *
     * @param string $validator Alias or FQ class name of the validator
     *
     * @return string
     */
    private static function checkValidator($validator)
    {
        if (!array_key_exists($validator, self::$validators)) {
            return self::checkClass($validator);
        }
        return self::$validators[$validator];
    }

    /**
     * Check if is a valid validator class
     *
     * @param string $validator FQ class name of validator
     *
     * @return string
     */
    private static function checkClass($validator)
    {
        if (! class_exists($validator)) {
            throw new InvalidArgumentException(
                "Class {$validator} does not exists."
            );
        }

        if (! is_subclass_of($validator, ValidatorInterface::class)) {
            throw new Exception\UnknownValidatorClassException(
                "The validator '{$validator}' is not defined or does not " .
                "implements the Slick\\Validator\\ValidatorInterface interface"
            );
        }

        return $validator;
    }

}


1		<?php
2
3		/**
4		* This file is part of slick/validator package
5		*
6		* For the full copyright and license information, please view the LICENSE
7		* file that was distributed with this source code.
8		*/
9
10		namespace Slick\Validator;
11
12		use Slick\Validator\Exception\InvalidArgumentException;
13
14		/**
15		* Static Validator
16		*
17		* @package Slick\Validator
18		* @author Filipe Silva <[email protected]>
19		*/
20		final class StaticValidator
21		{
22
23		/**
24		* @var array List of available validators
25		*/
26		public static $validators = [
27		'notEmpty' => 'Slick\Validator\NotEmpty',
28		'email' => 'Slick\Validator\Email',
29		'alphaNumeric' => 'Slick\Validator\AlphaNumeric',
30		'number' => 'Slick\Validator\Number',
31		'url' => 'Slick\Validator\Url'
32		];
33
34		/**
35		* @var array The error messages from last validation
36		*/
37		protected static $messages = [];
38
39		/**
40		* @var string
41		*/
42		protected static $message = '';
43
44		/**
45		* Returns true if and only if $value meets the validation requirements
46		*
47		* @param string $validator The validator name
48		* @param mixed $value
49		*
50		* @throws Exception\UnknownValidatorClassException
51		* @return bool
52		*
53		* @deprecated Should use the validates instead
54		*
55		* @see Slick\Validator\StaticValidator::$validators
56		*/
57		public static function isValid($validator, $value)
58		{
59		/** @var ValidatorInterface $validator */
60		$validator = static::create($validator);
		0 ignored issues – show Documentation introduced 2016-02-01 22:50 UTC by Report Bug Copy Issue Report `$validator` is of type `object<Slick\Validator\ValidatorInterface>`, 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...
61		$result = $validator->validates($value);
62		static::$messages[] = $validator->getMessage();
63		return $result;
64		}
65
66		/**
67		* Returns true if and only if $value meets the validation requirements
68		*
69		* The context specified can be used in the validation process so that
70		* the same value can be valid or invalid depending on that data.
71		*
72		* @param string $validator
73		* @param mixed $value
74		* @param array\|mixed $context
75		*
76		* @return bool
77		*/
78	2	public static function validates($validator, $value, $context = [])
79		{
80		/** @var ValidatorInterface $validator */
81	2	$validator = static::create($validator);
		0 ignored issues – show Documentation introduced 2016-02-01 22:50 UTC by Report Bug Copy Issue Report `$validator` is of type `object<Slick\Validator\ValidatorInterface>`, 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...
82	2	$result = $validator->validates($value, $context);
83	2	static::$message = $validator->getMessage();
		0 ignored issues – show Documentation Bug introduced 2016-02-02 17:27 UTC by Report Bug Copy Issue Report It seems like `$validator->getMessage()` of type `array` is incompatible with the declared type `string` of property `$message`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
84	2	return $result;
85		}
86
87		/**
88		* Creates a validator object
89		*
90		* @param string $validator The validator class name or alias
91		*
92		* @param null $message
93		* @throws Exception\UnknownValidatorClassException
94		*
95		* @return ValidatorInterface
96		*
97		*/
98	22	public static function create($validator, $message = null)
99		{
100	22	$class = self::checkValidator($validator);
101
102		/** @var ValidatorInterface $object */
103	18	$object = new $class;
104	18	if (!is_null($message)) {
105	2	$object->setMessage($message);
106	2	}
107	18	return $object;
108		}
109
110		/**
111		* Returns an array of messages that explain why the most recent
112		* isValid() call returned false. The array keys are validation failure
113		* message identifiers, and the array values are the corresponding
114		* human-readable message strings.
115		*
116		* @deprecated You should use instead the StaticValidator::getMessage()
117		*
118		* @return array
119		*/
120		public static function geMessages()
121		{
122		return static::$messages;
123		}
124
125		/**
126		* Returns the message that explain why the most recent
127		* validates() call returned false.
128		*
129		* @return array
130		*/
131	2	public static function geMessage()
132		{
133	2	return static::$message;
134		}
135
136		/**
137		* Check if the provided validator is a known alias or a valid validator
138		* interface class
139		*
140		* @param string $validator Alias or FQ class name of the validator
141		*
142		* @return string
143		*/
144	22	private static function checkValidator($validator)
145		{
146	22	if (!array_key_exists($validator, self::$validators)) {
147	6	return self::checkClass($validator);
148		}
149	16	return self::$validators[$validator];
150		}
151
152		/**
153		* Check if is a valid validator class
154		*
155		* @param string $validator FQ class name of validator
156		*
157		* @return string
158		*/
159	6	private static function checkClass($validator)
160		{
161	6	if (! class_exists($validator)) {
162	2	throw new InvalidArgumentException(
163	2	"Class {$validator} does not exists."
164	2	);
165		}
166
167	4	if (! is_subclass_of($validator, ValidatorInterface::class)) {
168	2	throw new Exception\UnknownValidatorClassException(
169	2	"The validator '{$validator}' is not defined or does not " .
170		"implements the Slick\\Validator\\ValidatorInterface interface"
171	2	);
172		}
173
174	2	return $validator;
175		}
176
177		}
178

slickframework / validator

StaticValidator::validates() A last analyzed 2016-02-02 17:27 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

StaticValidator::validates() A
last analyzed 2016-02-02 17:27 UTC