README

Easy and powerful validation library for PHP.

We use semantic versioning. See our releases.

Installation

composer require phputil/validator

Dependends only on phputil/rtti.

An Example

A step-by-step example for demonstrating its use.

// Suppose that your application receives an object in a JSON like this:
$json = <<<EXAMPLE
{
	"name": "Bob Developer",
	"likes": 150,
	"phone": { "number": "99988-7766", "notes": "WhatsApp, Telegram" },
	"friends": [ "Suzan", "Mike", "Jane" ]
}
EXAMPLE;
// So you transform the JSON into an object
$obj = json_decode( $json );
// Now you want to validate this object, and you create a Validator
$validator = new Validator();
// And define the rules
$rules = array(
	// name must have from 2 to 60 characters
	'name' => array( Rule::LENGTH_RANGE => array( 2, 60 ), Option::LABEL => 'Name' ),
	// likes must be greater or equal to zero
	'likes' => array( Rule::MIN_VAUE => 0 ),
	// for the phone...
	'phone' => array( Rule::WITH => array(
		// number must follow a regex
		'number' => array(
			Rule::REGEX => '/^[0-9]{5}\\-[0-9]{4}$/',
			Option::LABEL => 'Phone Number'
			)
	) ),
	// have a friend limit
	'friends' => array( Rule::MAX_COUNT => 100 )
);
// And define the messages (we also could load it from a JSON file)
$messages = array(
	'en' => array( // "en" means "english" locale. This is the default locale.
		Rule::LENGTH_RANGE => '{label} must have from {min_length} to {max_length} characters.',
		Rule::MIN_VAUE => '{label} must be greater than or equal to {min_value}.',
		Rule::REGEX => '{label} has an invalid format.',
		Rule::MAX_COUNT => '{label} must have up to {max_count} item(s).',
	)
);
$validator->setMessages( $messages );

// Now we will check the object using our rules
$problems = $validator->checkObject( $obj, $rules );
// In this moment, problems will be an empty array because all values passed.
// That is: $problems === array()

// However, lets make our rules harder, just to understand how the validation works
$rules[ 'name' ][ Rule::LENGTH_RANGE ] = array( 2, 5 ); // Max of 5
$rule[ 'friends' ][ Rule::MAX_COUNT ] = 1; // just one friend (the best one :-)

// And check again
$problems = $validator->checkObject( $obj, $rules );
// Now $problems is an array like this:
// array(
//	'name' => array( 'length_range' => 'Name must have from 2 to 5 characters.' ),
//	'friends' => array( 'max_count' => 'friends must have up to 1 item(s)' )
// )
// Which means that we have two fields with problems. The format is:
//  field => hurt rule => message
// For example, the field "name" hurt the "length_range" rule and its message is
// "Name must have from 2 to 5 characters.".
//
// If we need to know whether "name" has a problem, we just check with isset:
if ( isset( $problems[ 'name' ] ) ) {
	echo 'Name has a problem', PHP_EOL;
}
// If we are only interested in the messages, and don't care about the fields,
// we just use the ProblemsTransformer
$messages = ( new ProblemsTransformer() )->justTheMessages( $problems );
var_dump( $messages );
// Will print something like:
// array( 'Name must have from 2 to 5 characters.', 'friends must have up to 1 item(s)' )
//
// That's it for now. Enjoy it!

Features

Validates basic types (see example 1)
Validates arrays (see example 2)
Validates dynamic objects (stdClass) (see example 3)
Validates objects (of user-created classes) with private or protected attributes (see example 3)
Supports localized validation messages (different locales)
Supports different string formats (UTF, ISO-8859-1, ASCII, etc.)

Available Rules

required
min_length
max_length
length_range
min_value
max_value
value_range
min_count (for arrays)
max_count (for arrays)
count_range (for arrays)
in (for arrays)
not_in (for arrays)
start_with (accepts a string or an array of strings, compared with "or")
not_start_with (accepts a string or an array of strings, compared with "or")
end_with (accepts a string or an array of strings, compared with "or")
not_end_with (accepts a string or an array of strings, compared with "or")
contains (accepts a string or an array of strings, compared with "or")
not_contains (accepts a string or an array of strings, compared with "or")
regex
format: allows to use a format (see Available Formats)
with: allows to define rules for sub-arrays or sub-objects.
custom: you can add others easily. See below.

Adding a custom rule

// Adding a custom rule called "myRule" in which the value should be zero:
$validator->setRule( 'myRule', function( $value ) { return 0 == $value; } );

Now checking the custom rule:

$value = rand( 0, 5 ); // Value to be checked, a random between 0 and 5 (inclusive)
$rules = array( 'myRule' => true ); // Rules to be checked. In this example, just "myRule".
$problems = $validator->check( $value, $rules ); // check() will return the hurt rules
echo isset( $problems[ 'myRule' ] ) ? 'myRule as hurt' : 'passed';

Available Formats

anything
string (same as anything)
name
word
alphanumeric
alpha
ascii
numeric
integer
double
float (same as double)
monetary
price (same as monetary)
tax
date (equals to date_dmy)
date_dmy
date_mdy
date_ymd
time
longtime
datetime (equals to datetime_dmy)
datetime_dmy
datetime_mdy
datetime_ymd
longdatetime (equals to longdatetime_dmy)
longdatetime_dmy
longdatetime_mdy
longdatetime_ymd
email
http
url
ip
ipv4
ipv6
custom: you can add others easily. See below.

You may specify the separator for date-based formats. Default is "/", for example "31/12/1999".

Adding a custom format

// Adding a format "myFormat" in which the value should start with "https://"
$validator->setFormat( 'myFormat', function( $value ) {
	return mb_strpos( $value, 'https://' ) === 0;
	} );

Now checking the format:

$value = 'http://non-https-site.com';
$rules = array( Rule::FORMAT => 'myFormat' ); // rules to be checked
$problems = $validator->check( $value, $rules ); // check() returns the hurt rules
echo isset( $problems[ Rule::FORMAT ] ) ? 'myFormat as hurt' : 'passed';

Message Replacements

{min_length} shows the minimum length;
{max_length} shows the maximum length;
{length_range} shows the minimum and the maximum length (e.g. "5-10");
{min_value} shows the minimum value;
{max_value} shows the maximum value;
{value_range} shows minimum and maximum values (e.g. "5-10");
{min_count} shows the minimum count;
{max_count} shows the maximum count;
{count_range} shows the minimum count and the maximum count (e.g. "5-10");
{in} shows the set of items separated by comma;
{not_in} shows the set of items separated by comma;
{start_with} shows the string or the set of strings separated by comma;
{not_start_with} shows the string or the set of strings separated by comma;
{end_with} shows the string or the set of strings separated by comma;
{not_end_with} shows the string or the set of strings separated by comma;
{contains} shows the string or the set of strings separated by comma;
{not_contains} shows the string or the set of strings separated by comma;
{regex} shows the defined regex;
{label} shows the defined label, if defined. Otherwise, shows the array key or object attribute name;
{value} shows the value.

Notes:

{min_value} and {max_value} are available when the {value_range} is used;
{min_length} and {max_length} are available when the {length_range} is used;
{min_count} and {max_count} are available when the {count_range} is used.

Supports UTF-8 and other common formats (ISO-8859-1, Windows-1251, ASCII, etc.)
Error messages and formats can be specified by locale.
Error messages and formats can be specified at once. This allows you, for example, read them from a JSON file.
Formats and rules can be specified without having to extend any class.
Classes use a fluent interface (that is, you type less).
Builder classes available (soon)

Tests

See here.

Examples

See all

ex1.php - Validating values

ex2.php - Validating arrays

ex3.php - Validating objects

phputil / validator

Maintainers

Details