Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
Total | |
100.00% |
1 / 1 |
|
100.00% |
7 / 7 |
CRAP | |
100.00% |
25 / 25 |
Validator | |
100.00% |
1 / 1 |
|
100.00% |
7 / 7 |
19 | |
100.00% |
25 / 25 |
getValidator | |
100.00% |
1 / 1 |
5 | |
100.00% |
7 / 7 |
|||
fromString | |
100.00% |
1 / 1 |
3 | |
100.00% |
3 / 3 |
|||
__callStatic | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
__invoke | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
create | |
100.00% |
1 / 1 |
4 | |
100.00% |
9 / 9 |
|||
registerNamespace | |
100.00% |
1 / 1 |
2 | |
100.00% |
2 / 2 |
|||
resetNamespaces | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
getError | n/a |
0 / 0 |
1 | n/a |
0 / 0 |
|||||
getInverseError | n/a |
0 / 0 |
1 | n/a |
0 / 0 |
<?php | |
namespace Verja; | |
use Verja\Exception\ValidatorNotFound; | |
use Verja\Validator\Not; | |
/** | |
* Class Validator | |
* | |
* @package Verja | |
* @author Thomas Flori <thflori@gmail.com> | |
* | |
* @method static Validator\After after($dateTime) | |
* @method static Validator\Alpha alpha(bool $allowSpaces = false) | |
* @method static Validator\AlphaNumeric alphaNumeric(bool $allowSpaces = false) | |
* @method static Validator\Before before($dateTime) | |
* @method static Validator\Boolean boolean(array $stringTrue = [], array $stringFalse = [], $overwrite = false) | |
* @method static Validator\Between between($min = null, $max = null) | |
* @method static Validator\Callback callback(\Closure $callback) | |
* @method static Validator\Contains contains(string $subString) | |
* @method static Validator\CreditCard creditCard(string $subString) | |
* @method static Validator\DateTime dateTime(string $format = null, bool $strict = false) | |
* @method static Validator\EmailAddress emailAddress() | |
* @method static Validator\Equals equals(string $opposite, bool $jsonEncode = true) | |
* @method static Validator\InArray inArray($array) | |
* @method static Validator\Integer integer() | |
* @method static Validator\IpAddress ipAddress(string $version = 'any', string $range = 'any') | |
* @method static Validator\IsArray isArray(string $type) | |
* @method static Validator\Not not($validator) | |
* @method static Validator\NotEmpty notEmpty() | |
* @method static Validator\Numeric numeric(string $decimalPoint = '.') | |
* @method static Validator\PregMatch pregMatch(string $pattern) | |
* @method static Validator\Slug slug() | |
* @method static Validator\StrLen strLen(int $min, int $max = 0) | |
* @method static Validator\Truthful truthful() | |
* @method static Validator\Url url(string $coverage = 'complete', $schemes = ['https', 'http', 'ftp']) | |
*/ | |
abstract class Validator implements ValidatorInterface | |
{ | |
use WithAssignedField; | |
/** @var string[] */ | |
protected static $namespaces = [ '\\Verja\\Validator' ]; | |
/** @var array */ | |
protected $error; | |
/** | |
* Get a validator instance | |
* | |
* @param string|callable|ValidatorInterface $validator | |
* @return ValidatorInterface | |
* @throws ValidatorNotFound | |
*/ | |
public static function getValidator($validator) | |
{ | |
if (is_string($validator)) { | |
$validator = static::fromString($validator); | |
} elseif (is_callable($validator) && !$validator instanceof ValidatorInterface) { | |
$validator = new Validator\Callback($validator); | |
} | |
if (!$validator instanceof ValidatorInterface) { | |
throw new \InvalidArgumentException('$validator has to be an instance of ValidatorInterface'); | |
} | |
return $validator; | |
} | |
/** | |
* Create a Validator from $str | |
* | |
* This method uses Parser::parseClassNameWIthParameters. This method has some limitations for parameters - look | |
* at it's description to learn more. | |
* | |
* @param string $definition | |
* @return ValidatorInterface | |
* @see Parser::parseClassNameWithParameters() to learn how to pass parameters | |
* @throws ValidatorNotFound | |
*/ | |
public static function fromString(string $definition): ValidatorInterface | |
{ | |
if (strlen($definition) > 0 && $definition[0] === '!') { | |
return new Not(substr($definition, 1)); | |
} | |
return static::create(...Parser::parseClassNameWithParameters($definition)); | |
} | |
/** | |
* Create a validator dynamically | |
* | |
* @param string $name | |
* @param array $arguments | |
* @return ValidatorInterface | |
* @throws ValidatorNotFound | |
*/ | |
public static function __callStatic($name, array $arguments) | |
{ | |
return static::create(ucfirst($name), $arguments); | |
} | |
/** | |
* Call the validator is an alias for validate | |
* | |
* @param mixed $value | |
* @param array $context | |
* @return bool | |
*/ | |
public function __invoke($value, array $context = []): bool | |
{ | |
return $this->validate($value, $context); | |
} | |
/** | |
* Create a validator dynamically | |
* | |
* @param string $shortName | |
* @param array $parameters | |
* @return ValidatorInterface | |
* @throws ValidatorNotFound | |
*/ | |
public static function create(string $shortName, array $parameters = []): ValidatorInterface | |
{ | |
foreach (self::$namespaces as $namespace) { | |
$class = $namespace . '\\' . $shortName; | |
if (!class_exists($class)) { | |
continue; | |
} | |
$validator = new $class(...$parameters); | |
if (!$validator instanceof ValidatorInterface) { | |
continue; | |
} | |
return $validator; | |
} | |
throw new ValidatorNotFound($shortName); | |
} | |
/** | |
* Register an additional namespace | |
* | |
* @param string $namespace | |
*/ | |
public static function registerNamespace(string $namespace) | |
{ | |
array_unshift(self::$namespaces, $namespace); | |
// Untestable - required to reduce performance impact | |
// @codeCoverageIgnoreStart | |
if (count(self::$namespaces) > 2) { | |
self::$namespaces = array_unique(self::$namespaces); | |
} | |
// @codeCoverageIgnoreEnd | |
} | |
/** | |
* Reset namespaces to defaults | |
*/ | |
public static function resetNamespaces() | |
{ | |
self::$namespaces = [ '\\Verja\\Validator' ]; | |
} | |
/** | |
* {@inheritdoc} | |
* @codeCoverageIgnore trivial | |
*/ | |
public function getError() | |
{ | |
return $this->error; | |
} | |
/** | |
* The inverse error is not required to implement | |
* | |
* @param mixed $value | |
* @return null | |
* @codeCoverageIgnore trivial | |
*/ | |
public function getInverseError($value) | |
{ | |
return null; | |
} | |
} |