phputil/validator

Easy and powerful validator for PHP

2.5.2 2016-08-18 21:11 UTC

This package is auto-updated.

Last update: 2024-10-23 04:05:17 UTC


README

Easy and powerful validation library for PHP.

Build Status

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.

More

  • 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