Segue abaixo o link para os slides da palestra que vou apresentar amanhã no InterCon WP 2014. Utilize as setas do teclado para navegar entre os slides.
Categoria: php
Palestra sobre o WP-CLI no WordCamp BH 2014
Hoje dei uma palestra sobre o WP-CLI no WordCamp Belo Horizonte 2014.
O WP-CLI é um conjunto de ferramentas para gerenciar o WordPress na linha de comando.
A apresentação foi muito parecida com a que dei ano passado no WordCamp São Paulo. Fiz algumas pequenas modificações nos slides e publiquei eles no link abaixo:
Palestra sobre o WP-CLI no WordCamp São Paulo 2013
Amanhã vou dar uma palestra sobre o WP-CLI no WordCamp São Paulo 2013.
O WP-CLI é um conjunto de ferramentas para gerenciar o WordPress na linha de comando.
Segue abaixo o link para os slides que fiz para a apresentação:
Relato do WordCamp San Francisco 2013
Na última semana de julho, eu, Leo e Catia fomos, representando o Hacklab, para San Francisco para participar do WordCamp San Francisco 2013, o maior evento da comunidade do WordPress. Foi uma ótima oportunidade para conhecer alguns dos desenvolvedores da Automatic e saber quais são os planos para o futuro do projeto e da comunidade.
Os dois primeiros dias do evento foram dedicados a palestras dividas em duas trilhas. A primeira tinha como público alvo desenvolvedores e designers e a segunda usuários e empreendedores. O terceiro e último dia foi reservado para o Contributor Day, onde os interessados tem a oportunidade de contribuir diretamente com o WordPress.
Do primeiro dia destaco as palestras Confident Commits, Delightful Deploys do Mark Jaquith (slides) e a Writing Code as User Experience Design do Nikolay Bachiyski.
A palestra do Mark Jaquith tratou de boas práticas para todos os desenvolvedores e sysadmins que trabalham com WordPress, em especial na hora de publicar uma nova versão do código. Ele reforçou algumas coisas que já deveriam ser senso comum (e que infelizmente ainda não são), como o uso de um sistema de controle de versão. Também citou algumas ferramentas que facilitam bastante o fluxo de trabalho como o WP Stack ou o Capistrano-WP para fazer deploys, Puppet ou Chef que são ferramentas para o gerenciamento das configurações dos servidores e, por fim, o Vagrant para criar um ambiente de desenvolvimento semelhante ao servidor onde o site está publicado.
Na palestra do Nikolay Bachiyski, ele explorou o que os desenvolvedores podem aprender da experiência de quem estuda user experience design. Considerando que um desenvolvedor passa mais de 70% do seu tempo de trabalho lendo código e não escrevendo, quando criamos código temos que nos preocupar com a experiência do usuário, que neste caso serão os outros desenvolvedores que terão contato com ele. Além de sugerir algumas boas práticas para criação de código, ele mostrou alguns vídeos da tela e cara de alguns desenvolvedores enquanto estes criavam uma página usando a Settings API do WP.
Já do segundo dia destaco as palestras Three Security Issues You Thought You’d Fixed do Mike Adams e a Magical WordPress Management using WP-CLI do Mike Schroder (slides).
No último dia teve ainda o State of the Word 2013 do Matt Mullenweg. Nele o fundador do WordPress falou do crescimento do software que agora representa 18,9% de todo o conteúdo da web (ano passado era 16,7%), do uso crescente a partir de plataformas móveis e de um novo modelo de desenvolvimento para o core. A ideia é implementar ciclos mais curtos de release com o lançamento das versões 3.7 e 3.8 ainda esse ano e organizar os desenvolvedores do core em pequenos times que trabalhem em plugins. Quando um plugin estiver pronto ele é incorporado ao código principal. Este novo modelo já está sendo testado com o desenvolvimento da nova interface para o admin.
No Contributor Day trabalhei na automatização dos testes unitários do core do WordPress utilizando o Travis CI junto com o Bryan Petty e com a ajuda do Nikolai Bachiyski. Criamos um fork do repositório do WordPress no github e nele configuramos o serviço de integração continua que pode ser visto neste link. Nas próximas semanas o Andrew Nacin deve integrar o que fizemos no repositório do WordPress.
O arquivo de configuração que criamos para o Travis CI pode ser visto neste link. Ele roda os testes do WP usando PHP 5.2, 5.3 e 5.4 e para cada uma dessas versões com o modo multisite habilitado ou desabilitado. Por enquanto, o Travis só é chamado quando há um commit no core e não quando há um commit no repositório de testes. O próprio Nacin disse que a intenção é juntar os dois num único repositório.
Uma vez com a integração dos testes do WordPress com o Travis CI funcionando partimos para resolver os testes que estavam falhando. Conseguimos resolver cerca de dez testes, não deu tempo de resolver apenas um que foi resolvido uns dias depois. Após o WordCamp descobrimos mais três testes que falham quando executados com o PHP 5.2. Estes ainda estão pendentes e podem ser vistos na página do repositório no Travis CI.
Plugin do WordPress para usar o OpenID Delegation
No final do ano passado publiquei um plugin para WordPress que permite utilizar a URL de um blog rodando o WP como uma identidade OpenID.
Para usar o OpenID Delegation é necessário ter uma identidade OpenID em algum serviço como o myopenid.com.
Com este plugin ao invés de usar como identidade OpenID a URL fornecida pelo provider, é possível usar a URL do WordPress. No meu caso uso como identidade OpenID https://rodrigo.utopia.org.br ao invés de http://rodrigoprimo.myopenid.com/.
Para mais informações vejam a página do plugin: http://wordpress.org/extend/plugins/wordpress-openid-delegation/
Para quem estiver procurando um provider e/ou consumer OpenID vejam o plugin WordPress OpenID.
Como testar código que depende do sistema de arquivos com PHPUnit e vfsStream
Já faz um tempo que me interesso por testes unitários e em especial por TDD. Utilizo o PHPUnit, o principal framework da família xUnit para PHP. Neste post vou fazer uma rápida apresentação do vfsStream, um stream wrapper que permite simular um sistema de arquivos no PHP, facilitando muito a escrita de testes para código que manipula ou depende do sistema de arquivos.
Abaixo segue uma classe que utilizaremos como exemplo (para simplificar ela somente apresenta os elementos que interessam para este post):
<?php
class File
{
/**
* Path to the file
* @var string
*/
protected $path;
/**
*
* @param string $path
* @return null
*/
public function __construct($path)
{
$this->path = $path;
}
/**
* Add a string to the end of the file
* @param string $string
* @return null
*/
public function append($string)
{
file_put_contents($this->path, $string, FILE_APPEND);
}
/**
* Return file contents as a string
* @return string
*/
public function get()
{
return file_get_contents($this->path);
}
}
Se formos testar essa classe somente com os recursos oferecidos pelo PHPUnit, teríamos que criar e destruir os arquivos utilizando os métodos setUp() e tearDown() respectivamente. Isso funciona porém tem algumas complicações. Por exemplo, se por algum motivo a execução do teste for abortada, os arquivos criados não serão removidos do sistema de arquivos. Outro problema dessa abordagem é a manutenção dos testes quando o código a ser testado trabalha com múltiplos arquivos e/ou diretórios.
Utilizando o vfsStream não é necessário utilizar o tearDown() já que tudo é criado na memória e você tem mais controle e garantias sobre o ambiente de teste já que este é completamente virtual e não está sujeito a influência de outras operações que podem ocorrer enquanto os testes são executados.
Veja abaixo uma classe de testes que utiliza o vfsStream para testar os métodos descritos acima:
<?php
require_once('File.php');
require_once('vfsStream/vfsStream.php');
class FileTest extends PHPUnit_Framework_TestCase
{
protected $obj;
protected $file;
protected $string;
protected function setUp()
{
$this->string = "first line\n";
$root = vfsStream::setup();
$this->file = new vfsStreamFile('file.txt');
$this->file->setContent($this->string);
$root->addChild($this->file);
$this->obj = new File(vfsStream::url('file.txt'));
}
public function testAppend()
{
$string = "second line\n";
$expectedResult = "first line\n" . $string;
$this->obj->append($string);
$this->assertEquals($expectedResult, $this->file->getContent());
}
public function testGet()
{
$this->assertEquals($this->string, $this->obj->get());
}
}
No método FileTest::setUp(), a chamada ao vfsStream::setup() cria o diretório raiz do sistema de arquivos virtual e retorna um objeto do tipo vfsStreamDirectory. Na sequência, nas linhas 20 e 21, é criado um novo objeto do tipo vfsStreamFile e definido seu conteúdo inicial. Por fim na linha 22 o novo arquivo é adicionado a raiz do sistema de arquivos virtual e na linha 24 uma instância da classe que vamos testar é gerada recebendo como argumento o caminho para o arquivo.
O restante do código é auto explicativo para quem está acostumado com o PHPUnit, com exceção da linha 34 onde para verificar se o arquivo foi mesmo modificado é utilizado o método vfsStreamFile::getContent().
Para mais informações veja sobre o vfsStream sugiro: