Não é Feitiçaria, é Tecnologia

Não é feitiçaria, é tecnologia.
Metaprogramação com PHP

Adler Medrado
PHP Conference Brasil 2012

Monday, December 3, 12

Quem sou eu ?
• Desenvolvedor, Consultor,
Instrutor;
• Trabalha na Sigma Dataserv;
• Co-Fundador do PHPDF;
• Fui apresentado ao PHP em
1999;
• Tenho meu próprio podcast
(getOnCode);
• ZCE
• PHP 5;
• Zend Framework;

Meta

• Do grego, μετά
• após, além, adjacente

Indica o conceito de abstração de outro conceito, que
completa e adiciona a este último.


Metadado (metadata)
• Termo criado por Philip Bagley em 1986, na
obra “Extension of Programming Language
Concepts”;
• Dados sobre outros dados;
• Informa, descreve sobre o dado em
questão;
• Serve como marco ou ponto de referência;

Exemplos de
metadados
• XML
• Bancos de dados
• Anotações
• docComment
• YAML
• O próprio código, porque não?

Como podem ser
usados ?
• WSDL
• .svn, .git, etc.
• Arquivos de conﬁguração
• Dicionários de dados


O que é
metaprogramação ?
Alguns acham que é coisa de programador nerd
level hard


Ou feitiçaria, magia negra,
coisas assim...


MAS NÃO É


O que é
metaprogramação ?
• Fornece a capacidade de gerar ou alterar o
comportamento de um programa em
tempo de execução ou compilação baseado
em metadados;


Metaprogramação +
PHP
• O PHP não oferece tantos recursos como
o Ruby para utilizar tal técnica;
• Mas os recursos que já existiam somados a
outros oferecidos com o advento do PHP
5.3 e 5.4 nos permite fazer coisas
interessantes;


Metaprogramação +
PHP
• A maioria dos frameworks PHP atuais
utilizam recursos de metaprogramação em
algum ponto;


Metaprogramação +
PHP

• A propósito, eu arrisco dizer que você
também usa ou já usou tais recursos;


Metaprogramação +
PHP

• Você conhece os métodos mágicos do
PHP?
• Eles podem ser usados para alterar o
comportamento do objeto;


__get()
class Examples {

private $property;

public function __construct()
{
$this->property = 'Esse é um exemplo';
}

public function __get($property)
{
return $this->$property;
}

}

$e = new Examples;
echo $e->property;


__set($prop, $val)
class Examples {
private $property;
{
}

public function __get($property)
{
return $this->$property;
}

public function __set($property, $value)
{
$this->$property = $value;
}
}

$e = new Examples;
echo $e->property;
$e->property = '<br />mudei o valor<br />';
echo $e->property;


__call($name, $params)
<?php
class Exemplos {

private $property;

{
}

public function __call($name, $args)
{
echo 'invocando o método ' . $name . ' com os argumentos ' . join(', ' , $args);
}

}

$e = new Exemplos;
$e->umMetodoQualquer('param1', 'param2', 'param3');


OK, isso não é
metaprogramação, mas...
Demonstra que o
PHP é ﬂexível
Flexibilidade é ponto
chave em quase tudo


Falando em
ﬂexibilidade ...
Que tal adicionarmos propriedades em tempo de execução?

<?php
class Person {

}

$adler = new Person;
var_dump($adler);

object(Person)[1]

Não existem propriedades neste objeto.


Falando em
ﬂexibilidade ...
<?php
class Person {

}

$adler = new Person;

$adler->nome = 'Adler Medrado';
$adler->bonitao = true;

var_dump($adler);
?>

object(Person)[1]
public 'nome' => string 'Adler Medrado' (length=13)
public 'bonitao' => boolean true


Reﬂection API
• Desde a primeira release do PHP 5;
• Introspecção;
• Engenharia-Reversa;
• Acesso a metadados (PHPDoc);
• http://www.php.net/manual/en/
book.reﬂection.php


Reﬂection API
• Possíveis usos no mundo real;
• Geração de WSDL;
• Geração de formulários;
• Uso de anotações em PHP;
• Entre outros . . .
• Zend_XmlRpc usa Reﬂection;

Reﬂection API
Imagine a seguinte classe

<?php
class App {
private $name;
private $version;

public function __construct() {
$this->name = 'Exemplo';
$this->version = '1.0';
}

public function getVersion() {
return $this->version;
}
}


Reﬂection API
echo '<pre>';
ReflectionClass::export('App');
echo '</pre>';

Class [ class App ] {
@@ /Users/adler/Dropbox/palestras-phpconference-2012/metaprogramacao/reflection/sample_class.php 2-14

- Constants [0] {
}
- Static properties [0] {
}
- Static methods [0] {
}
- Properties [2] {
Property [ private $name ]
Property [ private $version ]
}
- Methods [2] {
Method [ public method __construct ] {
@@ /Users/adler/Dropbox/palestras-phpconference-2012/metaprogramacao/reflection/sample_class.php 6 - 9
}
Method [ public method getVersion ] {
@@ /Users/adler/Dropbox/palestras-phpconference-2012/metaprogramacao/reflection/sample_class.php 11 - 13
}
}
}


Reﬂection API
ReﬂectionClass -Invocando métodos

$r = new ReflectionClass('App');
echo $r->getMethod('getVersion')->invoke(new App());


Reﬂection API
ReﬂectionObject- Invocando métodos

$app = new App();
$r = new ReflectionObject($app);
echo $r->getMethod('getVersion')->invoke($app);


Quer ver um exemplo melhor?


Um simples gerador de
formulários

• Consiste em um gerador de formulário
HTML baseado em um objeto PHP;
• Pode ser incrementado posteriormente
implementando ﬁltros, validações, etc.;


Empresa.php

<?php
require 'ReflectionForm.php';

class Empresa extends ReflectionForm {

private $nome;
private $razao_social;
private $endereco;
private $bairro;
private $cidade;
private $estado;
private $telefone;
private $email;

}


ReﬂectionForm.php

<?php
abstract class ReflectionForm {

private $generated;

public function parse()
{

Obtém o objeto de Reﬂexão
$r = new ReflectionObject($this);

Obtém as propriedades
$fields = $r->getProperties();

array_walk($fields, function($field) {
$this->generated .= "<div>" . ucfirst($field->getName()) . "</div>n";
$this->generated .= "<div><input type="text" name="" . $field->getName() .
"" /></div>n";
});

return $this->generated;

}

}


exemplo.php

<?php
require 'Empresa.php';

$empresa = new Empresa();

?>
<html>
<head>
<title>Exemplo - Form Generator</title>
</head>
<body id="formGenerator">
<form action="" method="post" accept-
charset="utf-8">
<?=$empresa->parse(); ?>
</form>
</body>
</html>


Formulário gerado


HTML gerado


Annotations
• Injeção de comportamento;
• Desacoplamento;
• Aonde costuma ser usado?
• ORMs;
• Dependency Injection Container;


Annotations

• Não é um recurso nativo do PHP;
• Existem bibliotecas que fazem o trabalho
sujo;
https://wiki.php.net/rfc/annotations

Annotations
• Por essência, annotation é
metaprogramação;
• No PHP, annotation é uma simulação feita
usando a sintaxe PHPDoc + Reﬂection;
• Metaprogramação para implementar um
recurso de Metalinguagem;


Annotations
• Quem usa annotations no mundo PHP ?
• Doctrine;
• Symfony;
• Flow3 Framework;
• PHPUnit;


Annotations
• Bibliotecas que implementam annotations
• Doctrine/Common (packagist/composer);
• php-annotations (https://github.com/mindplay-dk/
php-annotations


Annotations
• Lembra do gerador de formulário?
• Que tal adicionarmos annotations a ele?


Empresa.php
<?php
require 'ReflectionForm.php';

class Empresa extends ReflectionForm {

/**
* @var string
* @type text
*/
private $nome;

/**
* @var string
* @type text
*/
private $razao_social;

/**
* @var string
* @type text
*/
private $endereco;

// Demais propriedades...
}


ReﬂectionForm.php

<?php
abstract class ReflectionForm {

private $metadataFields;

{
$this->metadataFields = array();
}


ReﬂectionForm.php (Continuação)

public function parse() {
$this->getFormInfo();
$generated = '';

foreach($this->metadataFields as $fieldName => $fieldParams) {

$generated .= "<div>" . ucfirst($fieldName) . "</div>n";
$generated .= "<div><input type=""
$generated .= $fieldParams['type'] . "" name=""
$generated .=. $fieldName . "" /></div>n";

}

return $generated;
}



private function getFormInfo() {

$r = new ReflectionObject($this);

$fields = $r->getProperties();

array_walk($fields, function($field) {

$lines = array();
$doc = $field->getDocComment();
if (preg_match('#^/**(.*)*/#s', $doc, $comment) === false) throw new
Exception('Error getting comment');

$params = trim($comment[1]);

if(preg_match_all('#^s**(.*)#m', $params, $lines) === false) throw new
Exception('Error getting lines');

foreach($lines[1] as $line) {
$this->getVariables($field->getName(), $line);
}
});
}



private function getVariables($fieldName, $line) {

$line = trim($line);

if(empty($line)) return false;

if(strpos($line, '@') === 0) {
$param = substr($line, 1, strpos($line, ' ') - 1);
$value = substr($line, strlen($param) + 2);

$this->metadataFields[$fieldName] = array($param => $value);
}
}


Formulário gerado

Mesmo resultado que o exemplo anterior


Geração de Código
Prazer, meu nome é eval()

<?php

$codigo = 'for ($i = 0; $i < 10; $i++) {';
$codigo .= 'echo 'Contando: ' . $i . '<br />';';
$codigo .= '}';

eval($codigo);

Contando: 0
Contando: 1
Contando: 2
Contando: 3
Contando: 4
Contando: 5
Contando: 6
Contando: 7
Contando: 8
Contando: 9


Lidando com objeto

• Anteriormente, adicionamos
propriedades a um objeto;
• Que tal adicionarmos um
método?


Antes, uma pergunta:

Você já usou lambda
functions com PHP?


De acordo com a documentação oﬁcial: Anonymous functions,
also known as closures, allow the creation of functions which
have no speciﬁed name. They are most useful as the value of
callback parameters, but they have many other uses.

<?php

$silvio = function() {
return "maaa oeeeee";
};

echo $silvio();


Criamos uma classe...
<?php
class Carro {

private $modelo, $ano, functionArgs;

public function __construct($modelo, $ano) {
$this -> modelo = $modelo;
$this -> ano = $ano;
}

public function ligar() {
echo "Ligando o carron";
}

public function __call($method, $args) {
if ($this->{$method} instanceof Closure) {
return call_user_func_array($this->{$method}, $args);
}
}
}


e adicionamos um
método
<?php
require 'Carro.php';

$carro = new Carro('Uno','1995');

$carro->ligar();

$str = '$carro->buzinar = function() {';
$str .= "echo "fom fom n";";
$str .= "};";

eval($str);

$carro->buzinar();

?>


Vamos adicionar um
método nessa classe?
public function createNewMethod($name, $args, $code) {

if ((!is_null($args)) && (sizeof($args) == 0)) {
array_walk($args, function($value) {
if (empty($this->functionArgs)) {
$this->functionArgs .= '$' . $value;
} else {
$this->functionArgs .= ',$' . $value;
}
});
}

$functionDefinition = '$this->{$name} = function ('. $this->functionArgs. ')';
$functionDefinition .= '{'.$code.'};';

eval($functionDefinition);
$this->functionArgs = null;

}


Adicionando método...
<?php
require 'Carro.php';

$carro = new Carro('Uno','1995');

$carro->ligar();
$carro->createNewMethod('buzinar', null, ' return "biii biin";');
echo $carro->buzinar();


Que tal deixar a classe
<?php
mais limpa?
trait genMetodo {
private $functionArgs;
public function createNewMethod($name, $args, $code) {
if ((!is_null($args)) && (sizeof($args) == 0)) {
array_walk($args, function($value) {

if (empty($this->functionArgs)) {
$this->functionArgs .= '$' . $value;
} else {
$this->functionArgs .= ',$' . $value;
}
});
}

$functionDefinition = '$this->{$name} = function ('. $this->functionArgs. ')';
$functionDefinition .= '{'.$code.'};';

eval($functionDefinition);
}

Obs: O método __call também pode ser deﬁnido na trait


Que tal deixar a classe
mais limpa?
<?php
class Carro {
use genMetodo;

private $modelo, $ano, $functionArgs;
public function __construct($modelo, $ano) {
$this->modelo = $modelo;
$this->ano = $ano;
}
public function ligar() {
echo "Ligando o carron";
}

public function __call($method, $args) {
if ($this -> {$method} instanceof Closure) {
return call_user_func_array($this -> {$method}, $args);
}
}
}


Perguntas?


Obrigado, até a próxima.
http://adlermedrado.com.br
http://getoncode.com.br
@adlermedrado


Não é Feitiçaria, é Tecnologia

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (11)

Semelhante a Não é Feitiçaria, é Tecnologia

Semelhante a Não é Feitiçaria, é Tecnologia (20)

Não é Feitiçaria, é Tecnologia