Widget WordPress: refactoring, parte 4
Abbiamo implementato una quantità significativa di modifiche al WordPress Widget Boilerplate. Se non hai seguito, ti consiglio di iniziare dall’inizio della serie e di recuperare il ritardo.
Se, tuttavia, hai seguito e stai anche eseguendo alcuni degli strumenti di qualità del codice che esaminano lo stato del progetto, noterai una manciata di errori nella console.
Normalmente, questo è il punto in cui consiglio di prestare attenzione a ciò che condivide e quindi di correggere ciò che segnala, ma non ci siamo ancora.
Ad esempio, alcuni degli errori che i nostri strumenti stanno mostrando in questo momento si basano sul fatto che abbiamo variabili inutilizzate. Naturalmente, questo è il caso, però, perché non abbiamo iniziato a creare un widget.
Ma ci sono ancora alcune classi concrete che dobbiamo implementare.
The WordPress Widget Boilerplate: Refactoring, Parte 4
Uno dei problemi che esistono ancora nel codice così com’è in questo momento è che il costruttore del widget sta registrando le funzioni e questa non è una buona cosa.
Lo scopo di un costruttore è impostare i valori delle proprietà della classe, non implementare alcun tipo di logica. Questo per alcuni motivi:
- crea un forte accoppiamento o dipendenze tra le classi nel progetto ogni volta che viene istanziata una determinata classe,
- introduce la logica aziendale in una funzione che non è destinata a contenere detta funzionalità,
- rende difficile testare una classe in isolamento.
Il modo per gestirlo è duplice:
- aggiungi un registro che possiamo usare per registrare le classi nell’applicazione (e passarle in giro con il minor numero possibile di dipendenze che spiegherò più avanti),
- creare abbonati in grado di gestire la logica aziendale su base hook-specific.
Nei prossimi tre post:
- esamineremo la creazione di un registro,
- come possiamo introdurlo nel file bootstrap,
- e poi guarda alla creazione di iscritti per ciascuna delle nostre funzioni (che non dovrebbe essere troppo difficile visto quello che abbiamo fatto nel post precedente e quello che stiamo facendo in questo post).
Crea il registro
Prima di scrivere il codice per il Registro, è importante notare qual è il suo scopo principale. In poche parole, la classe ha lo scopo di contenere un riferimento a qualsiasi classe che è, ehm, registrata con essa.
Questo viene fatto passando un riferimento a un determinato oggetto a una funzione e anche legandolo a una chiave in modo da poterlo recuperare facilmente in seguito.
Considerazioni iniziali
Ma ci sono alcune cose da considerare. Per esempio:
se esiste già un oggetto nel registro per una determinata chiave, allora è necessario generare un’eccezione: se un utente tenta di acquisire un oggetto dal registro con una determinata chiave, dovrebbe generare un’eccezione
Naturalmente, non deve necessariamente generare eccezioni. Al contrario, può anche visualizzare messaggi di errore, restituire valori null o vuoti o qualsiasi altra cosa tu scelga.
In secondo luogo, il registro deve essere in grado di restituire un elenco di tutti gli abbonati che sono contenuti al suo interno in modo che possano essere registrati con WordPress (che è quello che vedremo nel prossimo post).
Per fare questo, però, dobbiamo assicurarci che supporti tutti gli iscritti ed è qui che entra in gioco la nozione di AbstractSubscriber del post precedente . Cioè, finché una classe è una classe figlia di quella classe, allora siamo a posto.
Creazione del Registro
Detto questo, pianifichiamo quanto segue:
- Creeremo una classe Registry e la collocheremo in uno spazio dei nomi Utilities (e quindi in una directory) se non esiste già nel tuo lavoro.
- Faremo in modo che il registro mantenga un riferimento a tutti i suoi oggetti in un array associativo.
- Abbiamo bisogno di metodi per aggiungere e ottenere un singolo abbonato e poi uno per recuperare l’elenco di interi abbonati.
Lo stub per la classe sarà simile a questo:
<?php
class Registry extends AbstractSubscriber
{
public function __construct()
{
}
public function add($id, $obj)
{
}
public function get($id)
{
}
public function getRegisteredSubscribers()
{
}
}
Successivamente, possiamo definire la proprietà di base, un array e inizializzarlo nel costruttore:
<?php
class Registry
{
private $registry;
public function __construct()
{
$this->registry = [];
}
// ...
}Successivamente, possiamo creare il metodo add. Ricorda che nella mia implementazione, sto optando per generare un’eccezione se una chiave è già definita, ma non devi farlo.
<?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;
}Allo stesso modo, il metodo get restituirà un riferimento all’istanza di un oggetto identificato con quella chiave. Se la chiave non è impostata, genererà un’eccezione. Se è impostato, ma non esiste alcun oggetto, restituiremo 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;
}Infine, abbiamo bisogno di un metodo per restituire tutti gli abbonati registrati. In un post futuro, l’uso di questo diventerà molto più evidente, ma per ora, tieni presente che creeremo un array di qualsiasi classe che sia un’istanza della classe AbstractSubscriber e quindi restituiremo l’array filtrato.
<?php
public function getRegisteredSubscribers()
{
$subscribers = [];
foreach ($this->registry as $object) {
if ($object instanceof AbstractSubscriber) {
$subscribers[] = $object;
}
}
return array_filter($subscribers);
}A questo punto abbiamo la classe completa (completa di documentazione):
<?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);
}
}
Ora dobbiamo aggiungerlo al bootstrap del nostro plugin.
Prima di Bootstrap, però
Come accennato in precedenza nel post, dobbiamo aggiungerlo al bootstrap del plugin. Per fare ciò, però, dobbiamo definire il nostro filtro in modo da poter passare facilmente il registro intorno al resto del plugin (quando arriva il momento di farlo).
Prima di farlo, tuttavia, è importante assicurarsi di avere una buona gestione del registro che abbiamo appena creato, che si adatti al plug-in e che stai monitorando con il ramo di sviluppo che abbiamo finora.