Componentes, el arma secreta de Symfony2

#deSymfony Javier López | @loalf

domingo 17 de junio de 12

Javier López

Nací en Córdoba, España.

Vivo en Londres, Reino Unido.

Trabajo en IPC Media (http://ipcmedia.com).

Escribo (a veces) en mi blog (http://loalf.wordpress.com).

Twitteo como @loalf

... ¿quiéres saber más? http://www.linkedin.com/in/loalf


Los componentes


http://fabien.potencier.org/article/49/what-is-symfony2


Son un conjunto de librerías autónomas,
desacopladas y complementarias que resuelven
problemas comunes del desarrollo web


22 Componentes

EventDispatcher Validator

Browserkit ClassLoader Routing HttpFoundation

Filesystem Finder DependencyInjection Config

Security Console CssSelector Locale

Translation Form DomCrawler HttpKernel

Yaml Serializer Process Templating


Instalación


mkdir ComponentsPlayground
cd ComponentsPlayground
mkdir vendor
cd vendor
git clone https://github.com/symfony/symfony


autoload.php
<?php

require_once __DIR__.'/vendor/symfony/src/Symfony/Component/
ClassLoader/UniversalClassLoader.php';

use SymfonyComponentClassLoaderUniversalClassLoader;

$loader = new UniversalClassLoader();
$loader->registerNamespaces(array(
'Symfony' => __DIR__.'/vendor/symfony/src',
));

$loader->register();


ejemplo.php

<?php

require_once 'autoload.php';

/*
* Código del ejemplo
*/

> php ejemplo.php


Yaml


Parsea y genera archivos yml


parseando archivos YAML

#example.yml use SymfonyComponentYamlYaml;

descripcion: “Usuarios de symfony” $data = Yaml::parse('example.yml');
usuarios:
- print $data['descripcion'];
nombre: “Javi”
apellidos: “López” foreach( $data['usuarios'] as $usuario)
- {
nombre: “Raúl” print $usuario['nombre'].' '.
apellidos: “Fraile” $usuario['apellidos'];
}


generando archivos YAML

use SymfonyComponentYamlYaml;

$data['descripcion'] = "Usuarios de
symfony";
descripcion: “Usuarios de symfony”
$data['usuarios'][] = array( usuarios:
'nombre' => 'Javi', 0:
'apellidos' => 'Lopez' nombre: “Javi”
); apellidos: “López”
1:
$data['usuarios'][] = array( nombre: “Raúl”
'nombre' => 'Raul', apellidos: “Fraile”
'apellidos' => 'Fraile'
);

print Yaml::dump($data);


YAML & PHP

#example.yml

generado: <?php echo date(‘d-m-Y’); ?> use SymfonyComponentYamlYaml;
descripcion: “Usuarios de symfony”
usuarios: Yaml::enablePhpParsing();
javi:
nombre: “Javi” $data = Yaml::parse('example.yml');
apellidos: “López”
raul: print $data['generado'];
nombre: “Raúl”
apellidos: “Fraile”


Finder


Herramienta para encontrar archivos y directorios


buscando archivos por nombre

use SymfonyComponentFinderFinder;

$files = Finder::create()
->name("*.php")
->name("*.{php,yml}")
->name("/.(php|yml)$/")
->name("/^w{3,10}$/")
->name("foo.php")
->in(__DIR__);

Referencia sobre Patrones Glob: http://cowburn.info/2010/04/30/glob-patterns/


buscando archivos por tamaño


->size("> 10k")
->size("<= 4mi")
->size("2gi")
->in(__DIR__);

k = 1000 ki = 1024
m = 1000^2 mi = 1024^2
g = 1000^3 gi = 1024^3


buscando archivos por fecha


->date("since yesterday")
->date("until 2 days ago")
->date("> now - 2 hours")
->date(">= 2005-10-15 ")
->in(__DIR__);

Parámetro es cualquier argumento válido para strtotime()


ﬁjando el nivel de profundidad


->depth(0)
->depth(>1)
->depth(<3)
->in(__DIR__);


buscando sólo archivos


->files()
->in(__DIR__);


buscando sólo directorios


->directories()
->in(__DIR__);


obteniendo un resultado ordenado


->sortByName()
->sortByType()
->sort(
function(SplFileInfo $file1, SplFileInfo $file2){
return $file1->getSize() > $file2->getSize();
}
)
->in(__DIR__);


archivos php en la carpeta raíz del proyecto


->files()
->depth(0)
->name("*.php")
->in(__DIR__);


Process


Facilita la ejecución de comandos del sistema


¿está Twitter online?

use SymfonyComponentProcessProcess;

$process = new Process('ping -c 1 twitter.com');
$process->run();

if($process->isSuccessful()){
print "Twitter esta online";
}else{
print "Twitter esta offline";
}


ping -c 4 twitter.com


calculando tiempos medios de respuesta
$process = new Process('ping -c 4 twitter.com');
$process->run();

if($process->isSuccessful())
{
$output = $process->getOutput();

$pattern = '/time=(d+.d+) ms/';
preg_match_all($pattern, $output, $matches);
$average = array_sum($matches[1])/count($matches[1]);

printf("Avergage time=%.3f ms", $average);
}else{
print "Twitter está offline";
}


Validator


Ayuda a validar tanto variables como objetos


Validando que un valor sea no nulo

use SymfonyComponentValidatorConstraintsNotNull;
use SymfonyComponentValidatorConstraintsNotNullValidator;

$validator = new NotNullValidator();
if(!$validator->isValid(null, new NotNull()))
{
print $validator->getMessageTemplate();
// "The value should not be null"
}


24 Validadores
Blank Max Date

NotBlank Min Time

Null Url DateTime

NotNull Email Locale

True IP Language

False File Country

Choice Image Collection

Type Size Callback


Usando la clase Validator
use SymfonyComponentValidatorValidator;
use SymfonyComponentValidatorConstraintValidatorFactory;
use SymfonyComponentValidatorMappingBlackholeMetadataFactory;
use SymfonyComponentValidatorConstraints as Asserts;

$validator = new Validator(
new BlackholeMetadataFactory,
new ConstraintValidatorFactory
);

$errors = $validator->validateValue('', new AssertsNotBlank());
if($errors->count())
{
print $errors;
}
ConstraintViolationList


Validando un objeto (PHP)

class Person
{
public $name;
public $age;
}

$name no puede ser una cadena vacía
$age deberán ser un número comprendido entre 18 y 99 años



use SymfonyComponentValidatorMappingClassMetadataFactory;
use SymfonyComponentValidatorMappingLoaderStaticMethodLoader;

new ClassMetadataFactory(new StaticMethodLoader() ),
new ConstraintValidatorFactory()
);

$person = new Person();
$errors = $validator->validate($person);


use SymfonyComponentValidatorMappingClassMetadata;
use SymfonyComponentValidatorConstraint as Asserts;

class Person
{
public $name;
public $age;

static function loadValidatorMetadata(ClassMetadata $metadata)
{
$metadata
->addPropertyConstraint('name', new AssertsNotBlank())
->addPropertyConstraint('age' , new AssertsMin(18));
->addPropertyConstraint('age' , new AssertsMax(99));
}
}


Validando un objeto (YAML)

class Person
{
public $name;
public $age;
}

$name no puede ser una cadena vacía
$age deberán ser un número comprendido entre 18 y 99 años



# validate.yml

Person:
properties:
name:
- NotBlank : ~
age:
- Min: 18
- Max: 99



use SymfonyComponentValidatorMappingClassMetadataFactory;
use SymfonyComponentValidatorMappingLoaderYamlFileLoader;

new ClassMetadataFactory(
new YamlFileLoader(__DIR__.'/validate.yml')
),
new ConstraintValidatorFactory()
);

$person = new Person();
$errors = $validator->validate($person);


Serializer


Cuando todo es un array


Objeto

denormalize normalize

deserialize serialize
Array

encode
decode

Formato (JSON, XML)


Serializando un objeto
class Person
{
private $age;
private $name;

public function getName()
{
return $this->name;
}
public function getAge()
{
return $this->age;
}
public function setName($name)
{
$this->name = $name;
}
public function setAge($age)
{
$this->age = $age;
}
}


Serializando un objeto

use SymfonyComponentSerializerSerializer;
use SymfonyComponentSerializerEncoderXmlEncoder;
use SymfonyComponentSerializerEncoderJsonEncoder;
use SymfonyComponentSerializerNormalizerGetSetMethodNormalizer;

$person = new Person(19, 'Javi');

$encoders = array(new XmlEncoder(), new JsonEncoder() );

$normalizers = array(new GetSetMethodNormalizer());

$serializer = new Serializer($normalizers, $encoders);

$serializer->serialize($person, 'json');// {"name":"Javi","age":19}


Deserializando un objeto

data = <<<EOF
<person>
<name>Javi</name>
<age>19</age>
</person>
EOF;

$person = $serializer->deserialize($data,'Person','xml');


Console


Facilita la creación de tareas repetitivas


La consola más sencilla

// console.php

use SymfonyComponentConsoleApplication;

$console = new Application();
$console->run();


php console.php


php console.php help


php console.php help list


Hola mundo ... para consolas
use SymfonyComponentConsoleInputInputArgument;

$console
->register('hello')
->setDefinition(array(
new InputArgument('name', InputArgument::REQUIRED, 'Nombre'),
))
->setDescription('Saluda a una persona')
->setCode(function ($input, $output) {
$name = $input->getArgument('name');
$output->writeln(sprintf('Hola <info>%s</info>', $name));
})
;
$console->run();


Hay una manera mejor de hacerlo, Command


Creando un nuevo comando
use SymfonyComponentConsoleCommandCommand;
use SymfonyComponentConsoleInputInputArgument;

class HelloCommand extends Command
{
public function configure()
{
$this->setName('hello');
$this->setDefinition(array(
new InputArgument('name', InputArgument::REQUIRED, 'Nombre'),
))
$this->setDescription('Saluda a una persona')
}

public function execute($input, $output)
{
$name = $input->getArgument('name');
$output->writeln(sprintf('Hola <info>%s</info>', $name));
}
}


Creando un nuevo comando


$console->add(new HelloCommand());
$console->run();


Antes de irme


Divide y vencerás


Los tests son una excelente documentación


Check it out!
http://github.com:loalf/Sf2ComponentsPlayground.git


Gracias
@loalf IPC Media está reclutando, búscame si estás pensando en
mudarte a Londres

Créditos: http://www.ﬂickr.com/photos/normalityrelief/3075723695/


Componentes, el arma secreta de Symfony2

Más contenido relacionado

La actualidad más candente

Similar a Componentes, el arma secreta de Symfony2

Más de Javier López

Componentes, el arma secreta de Symfony2