simple-validator/simple-validator

Yet another validation class for PHP

Simple Validator Documentation

, _(*1)

Validation is the process that checks for correctness, meaningfulness and security of the input data. SimpleValidator is a library that handles validation process easily., _(*2)

Install

Including to your current composer.json

Add this line into require in your composer.json:, _(*3)

"simple-validator/simple-validator": "1.0.*"

and call, _(*4)

php composer.phar update

Installing directly

Download composer.phar and call, _(*5)

php composer.phar install

and use autoload.php to include the classes, _(*6)

require 'vendor/autoload.php'

A few examples:

<?php
$rules = [
    'name' => [
        'required',
        'alpha',
        'max_length(50)'
    ],
    'age' => [
        'required',
        'integer',
    ],
    'email' => [
        'required',
        'email'
    ],
    'password' => [
        'required',
        'equals(:password_verify)'
    ],
    'password_verify' => [
        'required'
    ]
];
$validation_result = SimpleValidator\Validator::validate($_POST, $rules);
if ($validation_result->isSuccess() == true) {
    echo "validation ok";
} else {
    echo "validation not ok";
    var_dump($validation_result->getErrors());
}

Custom Rules with anonymous functions

Anonymous functions make the custom validations easier to be implemented., _(*7)

Example

$rules = [
    'id' => [
        'required',
        'integer',
        'post_exists' => function($input) {
            $query = mysqli_query("SELECT * FROM post WHERE id = " . $input);
            if (mysqli_num_rows($query) == 0)
                return false;
            return true;
        },
        'between(5,15)' => function($input, $param1, $param2) {
            if (($input > $param1) && ($input < $param2))
                return true;
            return false;
        }
    ]
];

and you need to add an error text for your rule to the error file (default: errors/en.php)., _(*8)

'post_exists' => "Post does not exist"

or add a custom error text for that rule, _(*9)

$validation_result->customErrors([
    'post_exists' => 'Post does not exist'
]);

Another example to understand scoping issue

// my local variable
$var_to_compare = "1234";
$rules = [
    'password' => [
        'required',
        'integer',
        // pass my local variable to anonymous function
        'is_match' => function($input) use (&$var_to_compare) {
            if ($var_to_compare == $input)
                return true;
            return false;
        }
    ]
];

Custom Validators

You can assume SimpleValidator as a tool or an interface to create a validator for yourself., _(*10)

Custom validators can have their own rules, own error files or default language definitions. In addition, you can override default rules in your custom validator., _(*11)

class MyValidator extends \SimpleValidator\Validator {

    // methods have to be static !!!
    protected static function is_awesome($input) {
        if ($input == "awesome")
            return true;
        return false;
    }

    // overriding a default rule (url)
    protected static function url($input) {
        return preg_match('|^http(s)?://[a-z0-9-]+(.[a-z0-9-]+)*(:[0-9]+)?(/.*)?$|i', $input);
    }

    // set default language for your validator
    // if you don't override this method, the default language is "en"
    protected function getDefaultLang() {
        return getMyApplicationsDefaultLanguage();
    }

    // defining error files for your validator
    // in this example your files should live in "{class_path}/errors/{language}/validator.php
    protected function getErrorFilePath($lang) {
        return __DIR__ . "/errors/" . $lang . "/validator.php";
    }

}

Create an error file:, _(*12)

return [
    'is_awesome' => 'the :attribute is not awesome'
    // error text for url is already defined in default error text file you don't have to define it here, but optionally you can
];

And then, call the validate method., _(*13)

$rules = [
    'website' => [
        'is_awesome',
        'url'
    ]
];
$validation_result = MyValidator::validate($_POST, $rules);

Custom Rule parameters

A rule can have multiple parameters. An example:, _(*14)

$rule = [
    'id' => [
        'rule1(:input1,:input2,2,5,:input3)' => function($input, $input1, $input2, $value1, $value2, $input3) {
            // validation here
        }
    ],
    // and so on..
];

Custom Error messages

Using Error file

Custom rules provides localization for the error messages. Create a new file under errors folder, example: errors/es.php and call getErrors() method using:, _(*15)

$validation_result->getErrors('es');

Using customErrors method

You can add custom errors using customErrors method., _(*16)

Examples:

$validation_result->customErrors([
    // input_name.rule => error text
    'website.required' => 'We need to know your web site',
    // rule => error text
    'required' => ':attribute field is required',
    'name.alpha' => 'Name field must contain alphabetical characters',
    'email_addr.email' => 'Email should be valid',
    'email_addr.min_length' => 'Hey! Email is shorter than :params(0)',
    'min_length' => ':attribute must be longer than :params(0)'
]);

Naming Inputs

$naming => [
    'name' => 'Name',
    'url' => 'Web Site',
    'password' => 'Password',
    'password_verify' => 'Password Verification'
];
$validation_result = SimpleValidator\Validator::validate($_POST, $rules, $naming);

Output sample:

• Name field is required -instead of "name field is required"-
• Web Site field is required -instead of "url field is required"-
• Password field should be same as Password Verification -equals(:password_verify) rule-

More

You can explicitly check out the validations using has method that might be useful for Unit Testing purposes., _(*17)

// All return boolean
$validation_result->has('email');
$validation_result->has('email','required');
$validation_result->has('password','equals');

Default validations