Widgets de WordPress: Refactorización, Parte 4
Hemos implementado una cantidad significativa de cambios en el modelo estándar de widgets de WordPress. Si no ha estado siguiendo, le recomiendo comenzar desde el principio de la serie y ponerse al día.
Sin embargo, si ha estado siguiendo y también está ejecutando algunas de las herramientas de calidad de código que examinan el estado del proyecto, notará algunos errores en la consola.
Normalmente, este es el punto en el que recomiendo prestar atención a lo que comparte y luego corregir lo que informa, pero aún no hemos llegado allí.
Por ejemplo, algunos de los errores que están mostrando nuestras herramientas en este momento se basan en el hecho de que tenemos variables sin usar. Por supuesto, ese es el caso, sin embargo, porque no hemos comenzado a construir un widget.
Pero todavía hay algunas clases concretas que debemos implementar.
El modelo de widget de WordPress: refactorización, parte 4
Uno de los problemas que aún existen en el código tal como está ahora es que el constructor del widget está registrando funciones y esto no es bueno.
El propósito de un constructor es establecer los valores de las propiedades de la clase, no implementar ningún tipo de lógica. Esto se debe a algunas razones:
- crea un fuerte acoplamiento o dependencias entre las clases en el proyecto cada vez que se instancia una clase dada,
- introduce la lógica empresarial en una función que no pretende contener dicha funcionalidad,
- hace que sea difícil probar una clase de forma aislada.
La forma de manejar esto es doble:
- agregue un Registro que podamos usar para registrar clases en la aplicación (y pasarlas con la menor cantidad de dependencias posible, lo cual explicaré más adelante),
- crear suscriptores que puedan manejar la lógica empresarial en función de un enlace específico.
En las siguientes tres publicaciones:
- veremos cómo crear un Registro,
- cómo podemos introducirlo en el archivo de arranque,
- y luego observe cómo crear suscriptores para cada una de nuestras funciones (que no debería ser demasiado difícil dado lo que hicimos en la publicación anterior y lo que estamos haciendo en esta publicación).
Crear el registro
Antes de escribir el código para el Registro, es importante tener en cuenta cuál es su propósito principal. En pocas palabras, la clase debe contener una referencia a cualquier clase que esté, ejem, registrada con ella.
Esto se hace pasando una referencia a un objeto dado a una función y también vinculándola a una clave para que podamos recuperarla fácilmente más tarde.
Consideraciones iniciales
Pero hay algunas cosas a considerar. Por ejemplo:
si un objeto ya existe dentro del registro para una clave dada, entonces debemos lanzar una excepción; si un usuario intenta tomar un objeto del registro con una clave dada, entonces debería lanzar una excepción
Por supuesto, no necesariamente tiene que lanzar excepciones. En su lugar, también puede mostrar mensajes de error, devolver valores nulos o vacíos, o lo que elija.
En segundo lugar, el registro debe poder devolver una lista de todos los suscriptores que contiene para que puedan registrarse en WordPress (que es lo que veremos en la próxima publicación).
Sin embargo, para hacer esto, debemos asegurarnos de que sea compatible con todos los suscriptores y aquí es donde entra en juego la noción de AbstractSubscriber de la publicación anterior . Es decir, mientras una clase sea una clase secundaria de esa clase, entonces estamos bien.
Creando el Registro
Dicho esto, planeemos lo siguiente:
- Crearemos una clase de Registro y la colocaremos en un espacio de nombres de Utilidades (y, por lo tanto, en un directorio) si aún no existe en su trabajo.
- Haremos que el registro mantenga una referencia a todos sus objetos en una matriz asociativa.
- Necesitamos métodos para agregar y obtener un suscriptor individual y luego uno para recuperar la lista de suscriptores completos.
El resguardo de la clase se verá así:
<?php
class Registry extends AbstractSubscriber
{
public function __construct()
{
}
public function add($id, $obj)
{
}
public function get($id)
{
}
public function getRegisteredSubscribers()
{
}
}
A continuación, podemos definir la propiedad básica, una matriz, e inicializarla en el constructor:
<?php
class Registry
{
private $registry;
public function __construct()
{
$this->registry = [];
}
// ...
}Después de eso, podemos crear el método add. Recuerde que en mi implementación, opté por lanzar una excepción si ya se definió una clave, pero no tiene que hacerlo.
<?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;
}De manera similar, el método get devolverá una referencia a la instancia de un objeto identificado con esa clave. Si la clave no está configurada, generará una excepción. Si está configurado, pero no existe ningún objeto, devolveremos nulo.
<?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, necesitamos un método para devolver todos los suscriptores registrados. En una publicación futura, el uso de esto será mucho más evidente, pero por ahora, tenga en cuenta que crearemos una matriz de cualquier clase que sea una instancia de la clase AbstractSubscriber y luego devolveremos la matriz filtrada.
<?php
public function getRegisteredSubscribers()
{
$subscribers = [];
foreach ($this->registry as $object) {
if ($object instanceof AbstractSubscriber) {
$subscribers[] = $object;
}
}
return array_filter($subscribers);
}En este punto, tenemos la clase completa (completa con documentación):
<?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);
}
}
Ahora necesitamos agregarlo al bootstrap de nuestro complemento.
Antes de Bootstrap, aunque
Como se mencionó anteriormente en la publicación, debemos agregar esto al arranque del complemento. Sin embargo, para hacer esto, necesitamos definir nuestro propio filtro para que podamos pasar fácilmente el registro por el resto del complemento (cuando llegue el momento de hacerlo).
Sin embargo, antes de hacer eso, es importante asegurarse de que tiene un buen manejo del Registro que acabamos de crear, que encaja en el complemento y que está rastreando con la rama de desarrollo que tenemos hasta ahora.