Widgets do WordPress: Refatoração, Parte 4
Implementamos uma quantidade significativa de mudanças no WordPress Widget Boilerplate. Se você não tem acompanhado, recomendo começar no início da série e se atualizar.
Se, no entanto, você estiver acompanhando e também estiver executando algumas das ferramentas de qualidade de código que examinam o estado do projeto, notará alguns erros no console.
Normalmente, este é o ponto em que recomendo prestar atenção ao que ele compartilha e depois corrigir o que ele relata, mas ainda não chegamos lá.
Por exemplo, alguns dos erros que nossas ferramentas estão mostrando agora são baseados no fato de termos variáveis não utilizadas. Claro, esse é o caso, porque ainda não começamos a construir um widget.
Mas ainda existem algumas classes concretas que precisamos implementar.
The WordPress Widget Boilerplate: Refatoração, Parte 4
Um dos problemas que ainda existem no código como está agora é que o construtor do widget está registrando funções e isso não é uma coisa boa.
O objetivo de um construtor é definir os valores das propriedades da classe, não implementar nenhum tipo de lógica. Isso ocorre por alguns motivos:
- cria forte acoplamento ou dependências entre classes no projeto sempre que uma determinada classe é instanciada,
- ele introduz a lógica de negócios em uma função que não se destina a conter a referida funcionalidade,
- torna difícil testar uma classe isoladamente.
A maneira de lidar com isso é dupla:
- adicione um Registro que possamos usar para registrar classes na aplicação (e passá-las com o mínimo de dependências possível que explicarei mais adiante),
- crie assinantes que possam manipular a lógica de negócios em uma base específica de gancho.
Nos próximos três posts:
- veremos como criar um Registro,
- como podemos introduzi-lo no arquivo bootstrap,
- e, em seguida, veja como criar assinantes para cada uma de nossas funções (o que não deve ser muito difícil, considerando o que fizemos no post anterior e o que estamos fazendo neste post).
Criar o registro
Antes de escrever o código para o Registro, é importante observar qual é seu objetivo principal. Simplificando, a classe deve conter uma referência a qualquer classe que esteja registrada com ela.
Isso é feito passando uma referência a um determinado objeto para uma função e também ligando-o a uma chave para que possamos recuperá-lo facilmente mais tarde.
Considerações iniciais
Mas há algumas coisas a considerar. Por exemplo:
se um objeto já existe no registro para uma determinada chave, precisamos lançar uma exceção – se um usuário tentar pegar um objeto do registro com uma determinada chave, ele deve lançar uma exceção
Claro, não necessariamente tem que lançar exceções. Em vez disso, ele também pode exibir mensagens de erro, retornar valores nulos ou vazios ou o que você escolher.
Em segundo lugar, o registro precisa ser capaz de retornar uma lista de todos os assinantes que estão contidos nele para que possam ser registrados no WordPress (que é o que veremos no próximo post).
Para fazer isso, porém, precisamos ter certeza de que ele suporta todos os assinantes e é aí que a noção do AbstractSubscriber do post anterior entra em jogo. Isto é, desde que uma classe seja uma classe filha daquela classe, então tudo bem.
Criando o Registro
Dito isso, vamos planejar o seguinte:
- Criaremos uma classe Registry e a colocaremos em um namespace Utilities (e, portanto, em um diretório) se ela ainda não existir em seu trabalho.
- Faremos com que o registro mantenha uma referência a todos os seus objetos em uma matriz associativa.
- Precisamos de métodos para adicionar e obter um assinante individual e, em seguida, um para recuperar a lista de assinantes inteiros.
O stub da classe ficará assim:
<?php
class Registry extends AbstractSubscriber
{
public function __construct()
{
}
public function add($id, $obj)
{
}
public function get($id)
{
}
public function getRegisteredSubscribers()
{
}
}
Em seguida, podemos definir a propriedade básica, um array, e inicializá-lo no construtor:
<?php
class Registry
{
private $registry;
public function __construct()
{
$this->registry = [];
}
// ...
}Depois disso, podemos criar o método add. Lembre-se que na minha implementação, estou optando por lançar uma exceção se uma chave já estiver definida, mas você não precisa fazer isso.
<?php
public function add($id, $obj)
{
if (isset($this->registry[$id])) {
throw new Exception('An object already exists for this given key.');
}
$this->registry[$id] = $obj;
}Da mesma forma, o método get retornará uma referência à instância de um objeto identificado com essa chave. Se a chave não estiver definida, ela lançará uma exceção. Se estiver definido, mas não existir nenhum objeto, retornaremos null.
<?php
public function get($id)
{
if (!isset($this->registry[$id])) {
throw new Exception('No object exists for the specified key.');
}
return $this->registry[$id] ?? null;
}Finalmente, precisamos de um método para retornar todos os assinantes registrados. Em um post futuro, o uso para isso ficará muito mais aparente, mas, por enquanto, observe que criaremos um array de qualquer classe que seja uma instância da classe AbstractSubscriber e , em seguida, retornaremos o array filtrado.
<?php
public function getRegisteredSubscribers()
{
$subscribers = [];
foreach ($this->registry as $object) {
if ($object instanceof AbstractSubscriber) {
$subscribers[] = $object;
}
}
return array_filter($subscribers);
}Neste ponto, temos a classe completa (completa com documentação):
<?php
/*
* This file is part of the WordPress Widget Boilerplate
*
* (c) Tom McFarlin <tom@tommcfarlin.com>
*
* This source file is subject to the GPL license that is bundled
* with this source code in the file LICENSE.
*/
namespace WordPressWidgetBoilerplateUtilities;
use Exception;
use WordPressWidgetBoilerplateSubscriberAbstractSubscriber;
/**
* This class services as a simple container that can be used to pass objects
* around the plugin.
*
* To use this class you'd make a call to the registry by saying Registry->get(),
* then making a class to `register()` and `retrieve()` on an instance of the object.
*/
class Registry
{
/**
* @var array an array used to maintain the objects registered with the plugin
*/
private $registry;
/**
* Initializes the class by setting up the registry.
*/
public function __construct()
{
$this->registry = [];
}
/**
* Registers an object with the registry with the specified ID; however, will throw an
* exception if the ID is already referencing an object.
*
* @param string $id an ID by which the specified object will be referenced
* @param mixed $obj an instance of an object to store in the registry
*
* @throws Exception if an object already exists for the specified key
*/
public function add($id, $obj)
{
if (isset($this->registry[$id])) {
throw new Exception('An object already exists for this given key.');
}
$this->registry[$id] = $obj;
}
/**
* @param string $id the ID for the object that we wish to retrieve
*
* @throws Exception if no object exists for the specified key
*
* @return mixed a reference to the object or null
*/
public function get($id)
{
if (!isset($this->registry[$id])) {
throw new Exception('No object exists for the specified key.');
}
return $this->registry[$id] ?? null;
}
/**
* @return array all of the the Subscribers that should be registered with WordPress
*/
public function getRegisteredSubscribers()
{
$subscribers = [];
foreach ($this->registry as $object) {
if ($object instanceof AbstractSubscriber) {
$subscribers[] = $object;
}
}
return array_filter($subscribers);
}
}
Agora precisamos adicioná-lo ao bootstrap do nosso plugin.
Antes do Bootstrap, embora
Como mencionado anteriormente no post, precisamos adicionar isso ao bootstrap do plugin. Para fazer isso, porém, precisamos definir nosso próprio filtro para que possamos passar facilmente o registro pelo resto do plugin (quando chegar a hora de fazer isso).
Antes de fazermos isso, porém, é importante ter certeza de que você tem um bom controle sobre o Registro que acabamos de criar, que ele se encaixa no plug-in e que você está rastreando com a ramificação de desenvolvimento que temos até agora.