Domine Validação de Dados em 45min

30 de Novembro PHP Conference 2012 1

Domine

Validação de Dadosem 45min


Alexandre Gaigalashttp://about.me/alganet


@alganet


@alganet

Alfanumérico


@alganet

Alfanumérico Aceita _


@alganet


Sem espaços


@alganet


1-15 caracteresSem espaços


@alganet



/^[[:alnum:]_]{1,15}$/(Expressão Regular)


@alexandre_gomes_gaigalas



/^[[:alnum:]_]{1,15}$/


@al-ga-net



/^[[:alnum:]_]{1,15}$/


@Alexandre Gomes



/^[[:alnum:]_]{1,15}$/


E se eu quiser exibir os erros?


@alganet



if (!ctype_alnum(str_replace('_', '', $username))) echo “Username pode conter apenas letras, números e _”;


@alganet



if (!ctype_alnum(str_replace('_', '', $username))) echo “Username pode conter apenas letras, números e _”;if (strlen($username) < 1 || strlen($username) > 15) echo “Username pode conter de 1 a 15 caracteres”;


@alganet



$e = array();if (!ctype_alnum(str_replace('_', '', $username))) $e[] = “Username pode conter apenas letras, números e _”;if (strlen($username) < 1 || strlen($username) > 15) $e[] = “Username pode conter de 1 a 15 caracteres”;if ($e) echo implode($e);


E o erro para o “Sem espaços”?


@alganet



$e = array();if (!ctype_alnum(str_replace('_', '', $username))) $e[] = “Username pode conter apenas letras, números e _”;if (strlen($username) < 1 || strlen($username) > 15) $e[] = “Username pode conter de 1 a 15 caracteres”;if (false !== strpos($username, “ ”) $e[] = “Username não pode conter espaços”;/*...*/


Validation


use Respect\Validation\Rules as r;

$validator = new r\AllOf(

);

Construindo um Validator



$validator = new r\AllOf( new r\Alnum(“_”)

);




$validator = new r\AllOf( new r\Alnum(“_”), new r\NoWhitespace );




$validator = new r\AllOf( new r\Alnum(“_”), new r\NoWhitespace, new r\Length(1, 15));




$validator = new r\AllOf( new r\Alnum(“_”), new r\NoWhitespace, new r\Length(1, 15));

$isOk = $validator->validate(“alganet”);



Tem um jeito mais simples?


use Respect\Validation\Validator as v;

$validator = v::alnum('_') ->noWhitespace() ->length(1, 15);

$isOk = $validator->validate(“alganet”);

Construção via Fluent Builder


//true or false$validator->validate($algo);


E se eu quiser coletar os erros?


try { $validator->check(“e ae”);} catch (InvalidArgumentException $e) { echo $e->getMessage();}


use Respect\Validation\Exceptions as e;

/* … */

try { $validator->check(“e ae”);} catch (e\AlnumException $e) { //faz algo} catch (e\NoWhitespaceException $e) { //faz algo} catch (e\LengthException $e) { //faz algo}


//Dispara exception para o primeiro//erro$validator->check($algo);


E se eu quiser todos os erros?


try { $validator->assert(“e ae”);} catch (InvalidArgumentException $e) { echo $e->getFullMessage();}


\-All of the 3 required rules must pass |-"td errado#" must contain only letters (a-z) | and digits (0-9) |-"td errado#" must not contain whitespace \-"td errado#" must have a length between 1 and 15

$validator->assert(“td errado#”);


E se eu quiser agrupar só alguns erros?


try { $validator->assert(“e ae”);} catch (InvalidArgumentException $e) { $e->findMessages(array( 'alnum', 'length' ));}


E se eu quiser mensagens diferentes?


try { $validator->assert(“e ae”);} catch (InvalidArgumentException $e) { $e->findMessages(array( 'alnum' => “{{name}} Inválido”, 'length' => “Tamanho de {{name}} incorreto” ));}


//Dispara exception com todos os erros$validator->assert($algo);


E se eu quiser validar objetos inteiros?


class Tweet { public $text; public $created_at; public $user;}

class User{ public $name;}


$user = new User;$user->name = 'alganet';

$tweet = new Tweet;$tweet->user = $user;$tweet->text = “http://respect.li”; $tweet->created_at = new DateTime;


$tweetValidator = v::object() ->instance(“Tweet”) ->attribute(“text”, v::string()->length(1, 140)) ->attribute(“created_at”, v::date()) ->attribute(“user”, v::object() ->instance(“User”) ->attribute(“name”, $usernameValidator)) );










//Valida atributos de objetosv::object()->attribute(“name”);

//Valida chaves de arrayv::arr()->key(“email”);


//Valida atributos de objetosv::object()->attribute(“name”) //N atributos... ->attribute(“sex”);

//Valida chaves de arrayv::arr()->key(“email”) ->key(“sex”);


//Valida atributos de objetosv::object()->attribute(“name”) //N atributos... ->attribute(“sex”, //Valida o valor também v::in('F', 'M'));

//Valida chaves de arrayv::arr()->key(“email”) ->key(“sex”, v::in('F', 'M'));


E se eu quiser negar uma regra?


//Nega qualquer regrav::not(v::string());


E as mensagens pra regras negadas?


//”123” must be a stringv::string()->check(123);

//”bla bla” must not be a stringv::not(v::string())->check('bla bla');


Dá pra mudar o “123” e “bla bla” nas mensagens?


//Nome Completo must be a stringv::string() ->setName(“Nome Completo”) ->check(123);

//Idade must not be a stringv::not(v::string()) ->setName(“Idade”) ->check('bla bla');


//Validadores Básicos de Tipo

v::arr() v::date()v::float()v::int()v::nullValue()v::numeric()v::object()v::string()v::instance()


//Validadores Básicos de Comparação

v::equals($algo) // ==v::equals($algo, true) // ===v::max($a) // <v::max($a, true) // <=v::min($a) // >v::min($a, true) // >=v::between($a, $b) // >, <v::between($a, $b, true) // >=, <=


//Validadores Básicos Numéricos

v::even()v::odd()v::negative()v::positive()v::primeNumber()v::roman() // XVIv::multiple($algo)v::perfectSquare($algo)


//Validadores Básicos de String

v::alnum()v::alpha()v::digits()v::consonants()v::vowels()v::lowercase()v::uppercase()v::version()v::slug() // this-is-a-slugv::regex($exp)


//Validadores do Zendv::zend('Hostname')->check('google.com');

//Validadores do Symfonyv::sf('Time')->check('22:30:00');


//Validadores Legaisv::arr() ->each(v::instance(“MeuProduto”)) ->check($produtos); );


//Validadores Legais

v::between(1, 15) ->check(7);

v::between(“yesterday”, “tomorrow”) ->check(new DateTime);



v::minimumAge(18) ->check(“1987-07-01”);



v::leapDate() ->check(“1998-02-29”);

v::leapYear() ->check(“1998”);



v::contains(“bar”) ->check(“foo bar baz”);

v::startsWith(“foo”) ->check(“foo bar baz”);

v::endsWith(“baz”) ->check(“foo bar baz”);



v::contains(“bar”) ->check(array(“foo bar baz”));

v::startsWith(“foo”) ->check(array(“foo bar baz”));

v::endsWith(“baz”) ->check(array(“foo bar baz”));



v::oneOf( v::arr()->length(1, 15), v::object()->attribute(“items”));


Posso ter as minhas próprias regras?


v::callback(function ($input) { return $input === 42;});


Ok, mas posso ter meu próprio objeto?


use Respect\Validation;

class Universe implements Validation\Validatable extends Validation\Rules\AbstractRule{ public function validate($input) { return $input === 42; }}

v::int()->addRule(new Universe);


E as mensagens?


use Respect\Validation;

class UniverseException extends Validation\Exceptions\ValidationException{ public static $defaultTemplates = array( self::MODE_DEFAULT => array( self::STANDARD => '{{name}} must be 42', ), self::MODE_NEGATIVE => array( self::STANDARD => '{{name}} must not be 42', ) );}


Onde eu baixo?


github.com/Respect/ValidationPackagistrespect.li/pear



Perguntas?



Obrigado!

[email protected]

Domine Validação de Dados em 45min

Technology