Domine Validação de Dados em 45min

Domine
Validação de Dados
em 45min

30 de Novembro PHP Conference 2012 1

Alexandre Gaigalas
http://about.me/alganet


@alganet


Alfanumérico

@alganet


Alfanumérico Aceita _

@alganet



@alganet

Sem espaços



@alganet

Sem espaços 1-15 caracteres


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


@alganet



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


@alexandre_gomes_gaigalas



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


@al-ga-net



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


@Alexandre Gomes



E se eu quiser exibir os erros?


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


@alganet


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();
$e[] = “Username pode conter apenas letras, números e _”;
$e[] = “Username pode conter de 1 a 15 caracteres”;
if ($e)
echo implode($e);


@alganet


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


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


@alganet


Validation


Construindo um Validator
use RespectValidationRules as r;

$validator = new rAllOf(

);



new rAlnum(“_”)

);



new rAlnum(“_”),
new rNoWhitespace

);



new rNoWhitespace,
new rLength(1, 15)
);



new rNoWhitespace,
new rLength(1, 15)
);

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


Tem um jeito mais simples?


Construção via Fluent Builder

use RespectValidationValidator as v;

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

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


//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 RespectValidationExceptions as e;
/* … */

try {
$validator->check(“e ae”);
} catch (eAlnumException $e) {
//faz algo
} catch (eNoWhitespaceException $e) {
//faz algo
} catch (eLengthException $e) {
//faz algo
}

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


E se eu quiser todos os erros?


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


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

-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


E se eu quiser agrupar só alguns
erros?


try {
$e->findMessages(array(
'alnum', 'length'
));
}


E se eu quiser mensagens
diferentes?


try {
$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))
);

$tweetValidator
= v::object()
v::date())
v::object()
);

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

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


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

v::arr()->key(“email”)
->key(“sex”);


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

v::arr()->key(“email”)
->key(“sex”,
v::in('F', 'M'));


E se eu quiser negar uma regra?


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


E as mensagens pra regras
negadas?


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

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


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


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

//Idade must not be a string
v::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() // XVI
v::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-slug
v::regex($exp)

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

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


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



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”)

v::endsWith(“baz”)



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

v::startsWith(“foo”)

v::endsWith(“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 RespectValidation;

class Universe
implements ValidationValidatable
extends ValidationRulesAbstractRule
{
public function validate($input)
{
return $input === 42;
}
}

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

E as mensagens?


use RespectValidation;
class UniverseException
extends ValidationExceptionsValidationException
{
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/Validation
Packagist
respect.li/pear


Perguntas?

Packagist
respect.li/pear


Obrigado!
alexandre@gaigalas.net

Packagist
respect.li/pear


Domine Validação de Dados em 45min

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (15)

Similaire à Domine Validação de Dados em 45min

Similaire à Domine Validação de Dados em 45min (20)

Plus de Alexandre Gaigalas

Plus de Alexandre Gaigalas (11)

Dernier

Dernier (8)

Domine Validação de Dados em 45min