Tout savoir sur WordPress

WP Todolist – Développer une extension WordPress avec la POO – Partie 2

Dans une première partie, nous avons démarré une extension WordPress basée sur de la POO : WP Todolist. Nous avons créé notre premier custom post type afin de gérer nos todo. Cependant, une todo à différentes caractéristiques comme le fait d’avoir différents états (terminé, en cours, important, … ). Comment orienter notre développement pour répondre à ce besoin en programmation orientée objet ?

Actuellement, nous avons une todolist où l’on ne peut créer que des todo sans rien pouvoir en faire. Il serait intéressant maintenant de pouvoir les filtrer. Le but est d’avoir un aspect très dynamique au niveau de nos filtres afin d’être aussi flexible que ce que l’on pourrait faire avec Trello ! Une organisation de type : en test, en cours, en production par exemple ! Pour cela, nous allons devoir créer une taxonomy sur nos todo.

Pourquoi le choix de la taxonomy ?

Une taxonomy est une relation de type ManyToMany. C’est à dire qu’une taxonomy peut avoir un ou plusieurs custom post type et un custom post type peut appartenir à une ou plusieurs taxonomy. Or, l’état d’être en test ou en production pour une todo, c’est une relation ManyToOne. C’est à dire qu’un custom post type appartient à une et une seule taxonomy mais qu’une taxonomy peut avoir un ou plusieurs custom post type.  On va donc devoir régler ce problème à la main dans ce tutoriel. Dans l’idéal, je vous conseillerais plutôt d’utiliser ACF puisqu’il le fait déjà bien ! Mais nous ne sommes pas là pour utiliser ACF (mais si vous voulez en savoir plus, je vous invite à lire notre article ACF pour les débutants).

Pourquoi ne pas choisir une meta donnée ?

Une meta donnée dans WordPress est une relation de type OneToOne avec notre custom post type. Ce serait donc une erreur conceptuelle d’enregistrer l’information que nous souhaitons traiter en tant que meta donnée.

DU CÔTÉ DE LA TAXONOMY :  STATE

Je vais commencer par créer ma class Taxonomy que je vais nommer State.

<?php

// wp-todolist/src/Todolist/WordPress/Taxonomy/State.php
namespace Todolist\WordPress\Taxonomy;

use Todolist\Models\HooksInterface;
use Todolist\WordPress\Helpers\Taxonomy;
use Todolist\WordPress\Helpers\PostType;

/**
 * State
 *
 * @author Thomas DENEULIN <contact@wp-god.com>
 * @since 1.0.0
 * @version 1.0.0
 */
class State implements HooksInterface {

    public function hooks(){
        add_action( "init", array($this, 'initTaxonomy') );
    }

    public function initTaxonomy() {

        $labels = array(
            'name'              => __( 'State', 'td' ),
        );

        $args = array(
            'labels'             => $labels,
        );

        register_taxonomy( Taxonomy::STATE, array( PostType::CPT_TODO ), $args );        

    }
   
}

Cette class n’a rien d’extraordinaire. On retrouve l’implémentation de HooksInterface afin d’obtenir la méthode hooks et de pouvoir être exécuté sur l’initialisation du plugin. Ensuite, cette même méthode contient une action sur le hook init afin de créer les taxonomies sur la méthode initTaxonomy. J’ai également utilisé une class « Helper » afin de mettre en constante le nom de la taxonomy ; comme nous l’avions fait pour notre custom post type.

<?php
// wp-todolist/src/Todolist/WordPress/Helpers/Taxonomy.php

namespace Todolist\WordPress\Helpers;

/**
 *
 * @author Thomas DENEULIN
 * @version 1.0.0
 * @since 1.0.0
 */
abstract class Taxonomy{

    const STATE = "td-state";

}

Il nous reste à instancier notre class State (qu’il faut voir comme un service) lors de la création de nos actions. Rappelez-vous notre tableau : $actions se trouve dans notre fichier principal.

<?php

/**
 * Plugin Name: WP Todolist
 * Description: Gestion d'une Todolist dans WordPress
 * Version: 1.0.0
 * Author: <a href="http://twitter.com/TDeneulin" target="_blank">Thomas DENEULIN</a>
 */

require_once( dirname( __FILE__ ) . '/vendor/autoload.php' );

use Todolist\Todolist;
use Todolist\WordPress\PostType\Todo;
use Todolist\WordPress\Taxonomy\State;

$actions = array(
    new Todo(),
    new State()
);


$todolist = new Todolist($actions);
$todolist->execute();

Nous voilà maintenant avec notre taxonomy State qui va gérer l’état de nos todo. Maintenant, il faut nous attarder sur le fait de n’avoir qu’une seule taxonomy par custom post type mais avant ça…

Faisons une code review !

Oui ! Ça peut vous paraître un peu tôt car nous n’avons pas tant de code que ça. Cependant, je souhaite le faire rapidement pour vous sensibiliser au principe SOLID et au fait que nous pourrions déjà nous exclamer de quelques « WTF ?! » en regardant notre code… ! (la meilleur unité de mesure pour du code quality, je vous l’assure !)

Je me répète régulièrement en expliquant qu’une class doit être vue comme un service plus que comme simple objet qui nous permet de faire un package de méthodes bien organisées. Si l’on regarde d’un peu plus près notre class Todo (Todolist\WordPress\PostType\Todo) et notre class State (Todolist\WordPress\Taxonomy\State), nous débordons déjà !

En effet, elles font presque toutes les deux la même chose. L’une s’occupe de hooker la création d’un custom post type (CPT) et l’autre, la création d’une taxonomy. Maintenant, est-ce vraiment le rôle d’une class de ce type de connaître la procédure même de création d’un CPT ou d’une taxonomy ? Non.

Son seul et unique rôle serait de provoquer les hooks nécessaires à WordPress pour qu’une autre class s’occupe de créer en masse les taxonomies ou les custom post type…

Un scénario qui va nous éclaircir l’esprit

Dans mon plugin, je risque très fortement d’avoir besoin de plusieurs taxonomies (j’en suis même certain). En ce qui concerne les CPT, je ne sais pas trop mais sait-on jamais. De fait, pour faire bien faire les choses et continuer dans la lignée de notre développement, il faudrait :

  • Créer une nouvelle class avec le nom de notre taxonomy
  • Faire la méthode hooks pour avoir notre fonction callback qui va effectuer le register_taxonomy
  • Instancier notre class à la racine de notre plugin et le tour est joué.

Même scénario pour un custom post type. C’est répétitif n’est-ce pas ? Mais c’est plutôt propre.. ! Cependant, imaginez que vous souhaitiez faire un changement quelconque lors de la création de ces taxonomies. N’importe lequel tant que celui-ci doit être généralisé. Ou bien, si WordPress rajoute des paramètres, change le nom de la fonction, … Bref, un changement générique ! Il va vous falloir que vous repassiez sur X class taxonomy et/ou X class custom post type. En terme de maintenabilité ce n’est pas agréable, c’est plus long à tester et sur la durée, ce n’est pas fiable. Ne peut-on pas faire plus simple ? Une « super méga » fonction qui fait tout d’un coup à l’ancienne ? On en est pas loin.. !

Ce principe de création, cette forme d’usinage : le design pattern Factory

Le problème de conception que je viens d’évoquer est déjà résolu depuis de très nombreuses années, c’est le design pattern Factory. Nous avons donc là une première dette technique qui s’est formée. Nous en sommes conscient et nous pourrions résoudre la problématique immédiatement. Mais, ce n’est pas le sujet du jour et nous nous devons d’être pragmatique. Une sur-optimisation n’a pas encore lieu d’être. Dans un contexte personnel et pour le plaisir, faites-le, c’est très enrichissant. En revanche, dans un contexte professionnel il y a plusieurs paramètres à prendre en compte :

  • A-t’on le temps et l’argent nécessaire pour le faire ? (un client ne vous laisse pas le temps, n’a pas un budget conséquent pour vous permettre ce genre d’optimisation, … ? )
  • Est-ce rentable ? (si je compte vivre de ce plugin, il faudrait d’abord penser à le commercialiser plutôt qu’à le sur-optimiser ?)
  • Est-ce nécessaire au projet d’être le plus robuste possible tout de suite ?

Dans tous les cas, nous pouvons nous mettre une petite todo : « factoriser la création des taxonomies et des custom post type en implémentant le design pattern factory ».

Un et un seul état pour une todo

Avant d’écrire la première ligne de code, voyons d’abord de quelle manière nous pourrions aborder le problème afin de ne sélectionner un et un seul état pour une todo.

  • À l’enregistrement d’une todo, on fait en sorte de bloquer le résultat à une case à cocher maximum. Pas de changement de design, juste une validation plus stricte.
  • Une solution uniquement JavaScript ? Cependant, nous allons avoir les foudres des personnes qui rappellent que l’administration de WordPress est compatible en noscript. Il faudrait donc combiner cette solution à la première.
  • Changer l’apparence des checkbox en bouton radio et de fait, avoir une validation d’un seul choix.

Nous n’allons pas faire les fainéants avec la solution JavaScript même si je l’aime beaucoup. N’étant pas un très grand partisan du noscript, j’aurai pu ne faire que cette solution en fonction du besoin.  La première solution est aussi rapide mais pas très « user-friendly ». Soyons plutôt gourmand sur ce coup et changeons l’apparence des checkbox en bouton radio !

Apprenons de notre code review et ne pensons pas qu’à notre seule taxonomy State : généralisons la solution !

Pour cela, je veux donc l’équivalent d’une Factory qui va s’occuper de créer les boutons radio à la place des checkbox en fonction de la taxonomy que je vais lui envoyer. Avant de s’alarmer sur le mot Factory, je ne vais pas ressortir le modèle UML ni chercher à implémenter la définition même de la Factory puisque ce n’est pas possible dans notre cas. Ce patron de conception permet de retourner des instances d’objets. Or, nous allons nous servir uniquement de ce que je vais appeler « la logique de fond » du design pattern qui a pour but, au final, de créer quelque chose.

Avant de se lancer dans les explications, je vous ai schématisé la logique que l’on va appliquer afin d’utiliser convenablement notre factory. Ce sera notre ligne directrice pour savoir les class que nous allons devoir utiliser.

schema

 

Nous allons donc avoir 3 class pour implémenter cette logique :

  • RadioTaxonomy : c’est un service qui va effectuer l’intermédiaire entre notre demande, qu’est de transformer les boutons des taxonomies en checkbox et, la factory qui est capable d’effectuer cette modification.
  • RadioTaxonomyFactory : notre factory qui va générer les boutons radios. Elle ne va pas contenir toute la logique de création car c’est trop lourd pour cette class. En revanche, elle va se servir d’un handler qui contiendra toute la logique nécessaire aux boutons radios.
  • RadioTaxonomyHandler : Ce handler contient toute la logique nécessaire aux boutons radios.

Rappel : on donne à une class ce dont elle a besoin pour fonctionner

Place au code afin d’avoir une meilleur visibilité à toutes ces explications.

 

 

<?php

// wp-todolist/src/Todolist/WordPress/Services/RadioTaxonomy.php
namespace Todolist\WordPress\Services;

use Todolist\Models\HooksInterface;

/**
 * RadioTaxonomy
 *
 * @author Thomas DENEULIN <contact@wp-god.com>
 * @since 1.0.0
 * @version 1.0.0
 */
class RadioTaxonomy implements HooksInterface {

    public function __construct($radioTaxonomyFactory, $taxonomies = array()){

        $this->radioTaxonomyFactory = apply_filters('td_radio_taxonomy_factory', $radioTaxonomyFactory);
        $this->taxonomies           = apply_filters('td_radio_taxonomies', $taxonomies);
        
    }

    /**
     * @see Todolist\Models\HooksInterface
     */
    public function hooks(){
        add_action( 'registered_taxonomy', array( $this, 'loadRadioTaxonomy' ) );
    }

    public function getTaxonomies(){
        return $this->taxonomies;
    }

    public function loadRadioTaxonomy($taxonomy){
        if(!in_array($taxonomy, $this->getTaxonomies())){
            return false;
        }

        $this->radioTaxonomyFactory->createRadioButton($taxonomy);
    }

   
}

On constate encore une fois que ce service implémente HooksInterface. C’est un service qui s’active lors de l’exécution du plugin.

  • Ligne 17 : Le constructeur contient deux paramètres :
    • $radioTaxonomyFactory : On donne au service la factory sur laquelle il peut travailler. On ajoute également un filtre WordPress pour que quelqu’un puisse la changer sans pour autant changer le code du plugin.
    • $taxonomies : un tableau de taxonomy. Il contient les taxonomies pour lesquelles nous souhaitons modifier les checkbox en bouton radio. Il y a également un filtre pour que l’on puisse venir ajouter d’autres taxonomies que celles du plugin. (* voir à la fin du tutoriel une note sur cette possibilité)
  • Ligne 35 : Cette fonction intervient sur le hook registered_taxonomy. Elle vérifie que la taxonomy en cours d’enregistrement existe dans notre tableau de taxonomies à modifier. Si jamais il y a besoin de modifier notre taxonomy, on fait appel à la factory !

Pour instancier ce service, voici notre fichier wp-todolist.php avec toutes les modifications que l’on va lui apporter :

<?php

/**
 * Plugin Name: WP Todolist
 * Description: Gestion d'une Todolist dans WordPress
 * Version: 1.0.0
 * Author: <a href="http://twitter.com/TDeneulin" target="_blank">Thomas DENEULIN</a>
 */

require_once( dirname( __FILE__ ) . '/vendor/autoload.php' );

use Todolist\Todolist;

use Todolist\WordPress\Helpers\Taxonomy;

use Todolist\WordPress\PostType\Todo;

use Todolist\WordPress\Taxonomy\State;

use Todolist\WordPress\Services\RadioTaxonomy;
use Todolist\WordPress\Services\RadioTaxonomyFactory;

define("TD_PLUGIN_PATH", plugin_dir_path( __FILE__ ));
define("TD_PLUGIN_DIR_TEMPLATES", TD_PLUGIN_PATH . "templates" );
define("TD_PLUGIN_DIR_TEMPLATES_ADMIN", TD_PLUGIN_DIR_TEMPLATES . "/admin" );

$actions = array(
    new Todo(),
    new State(),
    new RadioTaxonomy(
        new RadioTaxonomyFactory(),
        array(
            Taxonomy::STATE
        )
    )
);


$todolist = new Todolist($actions);
$todolist->execute();
  • Ligne 23-25 : j’ai créé des constantes afin d’accéder aux chemins des fichiers dont nous allons avoir besoin, notamment celui qui correspond au template des boutons radios.
  • Ligne 30-35 : je crée le service que l’on vient de voir au dessus en lui passant les paramètres nécessaires à sa construction : la RadioTaxonomyFactory et l’unique taxonomy dont on va se servir pour l’instant.

Place à notre factory :

<?php

// wp-todolist/src/Todolist/WordPress/Services/RadioTaxonomyFactory.php
namespace Todolist\WordPress\Services;

use Todolist\Exception\TaxonomyObjectNotExist;
use Todolist\Exception\InterfaceException;
use Todolist\WordPress\Handler\RadioTaxonomyHandler;
use Todolist\Models\RadioTaxonomyInterface;

/**
 * RadioTaxonomyFactory
 *
 * @author Thomas DENEULIN <contact@wp-god.com>
 * @since 1.0.0
 * @version 1.0.0
 */
class RadioTaxonomyFactory {


    public function createRadioButton($taxonomy){
        $taxonomyObject = get_taxonomy( $taxonomy );

        if($taxonomyObject === false){
            throw new TaxonomyObjectNotExist(__("Taxonomy does not exist", "td"));
        }

        $radioTaxonomyHandler = apply_filters('td_radio_taxonomy_handler', new RadioTaxonomyHandler());

        if(!$radioTaxonomyHandler instanceOf RadioTaxonomyInterface){
            throw new InterfaceException(__("Handler not implements RadioTaxonomyInterface", "td"));    
        }

        $radioTaxonomyHandler->setTaxonomy($taxonomy)
                             ->setTaxonomyObject($taxonomyObject)
                             ->createRadioButton();

    }
   
}
  • Ligne 25 : on retrouve ici l’une des deux exceptions personnalisées de notre plugin. Je n’en ai pas encore parlé car ce n’est pas le but recherché sur ce tutoriel. Je vous invite à aller voir le code source sur GitHub si cela vous intéresse.
  • Ligne 28 : j’instancie le handler qui va nous permettre de faire les modifications que l’on souhaite. Encore un filtre WordPress si jamais vous souhaitez faire votre propre handler. Peut-être avez-vous une meilleur solution ou souhaitez-vous faire autrement ? Toujours est-il que pour que vous puissiez passer dans la factory, votre handler devra implémenter la RadioTaxonomyInterface ! Elle contient 5 méthodes : 2 setters / 2 getters  et la méthode createRadioButton.
  • Ligne 31 : une autre exception personnalisée.
  • Ligne 34-36 : je fais de l’injection de dépendance grâce aux setters de mon handler. Je lui donne la taxonomy sur laquelle il doit travailler ainsi que le résultat de la fonction get_taxonomy. Puis, il ne lui reste plus qu’à créer le bouton !

Pour le handler, je ne vais pas vous mettre tout le code mais uniquement les parties que je souhaite développer puisqu’il est disponible sur GitHub et qu’il est plus important que les autres.

<?php

// wp-todolist/src/Todolist/WordPress/Handler/RadioTaxonomyHandler.php
namespace Todolist\WordPress\Handler;

use Todolist\Models\RadioTaxonomyInterface;
use Todolist\WordPress\Walker\RadioTaxonomyWalker;

/**
 * RadioTaxonomyHandler
 *
 * @author Thomas DENEULIN <contact@wp-god.com>
 * @since 1.0.0
 * @version 1.0.0
 */
class RadioTaxonomyHandler implements RadioTaxonomyInterface {

    // ....

    /**
     * @see Todolist\Models\RadioTaxonomyInterface
     */
    public function createRadioButton(){

        add_action( 'admin_menu', array( $this, 'removeMetaBox' ) );
        add_action( 'add_meta_boxes', array( $this, 'addMetaBox' ) );
        add_filter( 'wp_terms_checklist_args', array( $this, 'filterChecklistArgs' ) );

        add_action( 'save_post', array( $this, 'saveOneTerm' ) );
        add_action( 'edit_attachment', array( $this, 'saveOneTerm' ) );

        add_action( 'load-edit.php', array( $this, 'hierarchicalTaxonomy' ) );
        add_action( 'quick_edit_custom_box', array( $this, 'quickEditCustomNonce' ) );  
    }



    public function addMetaBox() {
        foreach ( $this->getTaxonomyObject()->object_type as $postType ){
            $label = $this->getTaxonomyObject()->labels->singular_name;
            $id    = (!is_taxonomy_hierarchical( $this->getTaxonomy() )) ? 'radio-tagsdiv-' . $this->getTaxonomy() : 'radio-' . $this->getTaxonomy() . 'div' ;

            add_meta_box( $id, $label ,array( $this,'radioMetabox' ), $post_type , 'side', 'core', array( 'taxonomy'=>$this->getTaxonomy() ) );
        }
    }

  
    public function radioMetabox( $post, $metabox ) {
        $defaults = array(
            'taxonomy' => 'category'
        );
        $args     = array();
        if (isset($metabox['args']) || is_array($metabox['args']) ){
            $args = $metabox['args'];
        }

        $args           = wp_parse_args($args, $defaults);
        $checked_terms  = $post->ID ? get_the_terms( $post->ID, $args["taxonomy"] ) : array();
        
        $single_term    = ! empty( $checked_terms ) && ! is_wp_error( $checked_terms ) ? array_pop( $checked_terms ) : false;
        $single_term_id = $single_term ? (int) $single_term->term_id : 0;

        include_once(apply_filters("td_radio_taxonomy_metabox", TD_PLUGIN_DIR_TEMPLATES_ADMIN . "/radio-taxonomy-metabox.php"));
    }

    public function filterChecklistArgs($args){

        if( !array_key_exists("taxonomy", $args) || $this->getTaxonomy() != $args['taxonomy'] ) {
            return $args;
        }

        $args['walker']        = apply_filters('td_radio_taxonomy_walker', new RadioTaxonomyWalker());
        $args['checked_ontop'] = false;

        return $args;
    }

    // ....
   
}

Vous avez donc la liste de tous les hooks dont on a besoin. Je supprime la metabox qui servait aux checkbox pour créer notre propre metabox. Ensuite, lorsque ma nouvelle metabox va lister les différents terms de la taxonomy grâce à la fonction wp_terms_checklist je vais lui associer un Walker spécifique : celui qui va permettre d’afficher des boutons radios. Cette fonction peut déjà prendre en paramètre un walker mais j’ai préféré le hooker sur wp_terms_checklist_args.

Vous constaterez que je n’ai pas écris d’HTML dans ce fichier. Or, il faudra bien le faire au niveau du callback de la fonction add_meta_box (radioMetabox). En effet, je trouve ça illisible de voir du PHP et du HTML se mélanger à ce niveau là alors qu’il y a d’autres solutions comme on peut le voir à la ligne 63. Je vais inclure le fichier HTML qui va contenir tout ce que je souhaite. Il peut vous arriver de devoir stocker du HTML dans une variable. Pour cela, il vous suffit de jouer avec les fonctions ob_start / ob_flush / ob_end

Concernant ce fichier, je n’ai pas réinventé la roue et je suis aller voir les templates de WordPress. J’adapte ensuite en fonction de mes besoins.

  • Ligne 72 : on retrouve ici le Walker que j’instancie afin de filtrer ma fonction wp_terms_checklist uniquement sur les taxonomies qui en ont besoin. Il y a de nouveau un filtre si jamais vous voulez votre propre Walker !

En ce qui concerne le Walker, celui-ci hérite du Walker_Category de WordPress. J’ai uniquement besoin de surcharger la méthode start_el afin d’afficher les boutons radios que je souhaite. Ca peut paraître lourd pour modifier le type radio sur l’input… mais WordPress n’a toujours pas de Walker pour les afficher comme des boutons radios. C’est quelque chose que l’on pourrait proposer dans un ticket cette affaire… !

<?php

// wp-todolist/src/Todolist/WordPress/Walker/RadioTaxonomyWalker.php
namespace Todolist\WordPress\Walker;


/**
 * RadioTaxonomyWalker
 *
 * @author Thomas DENEULIN <contact@wp-god.com>
 * @since 1.0.0
 * @version 1.0.0
 */
class RadioTaxonomyWalker extends \Walker_Category {


    /**
     * Start the element output.
     *
     * @see Walker::start_el()
     *
     * @since 2.5.1
     *
     * @param string $output   Passed by reference. Used to append additional content.
     * @param object $category The current term object.
     * @param int    $depth    Depth of the term in reference to parents. Default 0.
     * @param array  $args     An array of arguments. @see wp_terms_checklist()
     * @param int    $id       ID of the current term.
     */
    public function start_el( &$output, $category, $depth = 0, $args = array(), $id = 0 ) {
        
        $taxonomy = 'category';
        if ( !empty( $args['taxonomy'] ) ) {
            $taxonomy = $args['taxonomy'];
        }


        $name                  = 'radio_tax_input['.$taxonomy.']';
        
        $args['popular_cats']  = empty( $args['popular_cats'] ) ? array() : $args['popular_cats'];
        $class                 = in_array( $category->term_id, $args['popular_cats'] ) ? ' class="popular-category"' : '';
        
        $args['selected_cats'] = empty( $args['selected_cats'] ) ? array() : $args['selected_cats'];
        
        $selected_term         = !empty( $args['selected_cats'] ) && ! is_wp_error( $args['selected_cats'] ) ? array_pop( $args['selected_cats'] ) : false;
    
        $selected_id           = ( $selected_term ) ? $selected_term : 0;

        if ( ! empty( $args['list_only'] ) ) {
            $aria_cheched = 'false';
            $inner_class = 'category';

            if ( in_array( $category->term_id, $args['selected_cats'] ) ) {
                $inner_class .= ' selected';
                $aria_cheched = 'true';
            }

            $output .= "\n" . '<li' . $class . '>' .
                '<div class="' . $inner_class . '" data-term-id=' . $category->term_id .
                ' tabindex="0" role="radio" aria-checked="' . $aria_cheched . '">' .
                esc_html( apply_filters( 'the_category', $category->name ) ) . '</div>';
        } else {

            $output .= "\n<li id='{$taxonomy}-{$category->term_id}'$class>" .
                '<label class="selectit"><input value="' . $category->term_id . '" type="radio" name="'.$name.'[]" id="in-'.$taxonomy.'-' . $category->term_id . '"' .
                checked( $category->term_id, $selected_id, false ) .
                disabled( empty( $args['disabled'] ), false, false ) . ' /> ' .
                esc_html( apply_filters( 'the_category', $category->name ) ) . '</label>';
        }
    }

    /**
     * Ends the element output, if needed.
     *
     * @since 2.1.0
     * @access public
     *
     * @see Walker::end_el()
     *
     * @param string $output Passed by reference. Used to append additional content.
     * @param object $page   Not used.
     * @param int    $depth  Optional. Depth of category. Not used.
     * @param array  $args   Optional. An array of arguments. Only uses 'list' for whether should append
     *                       to output. See wp_list_categories(). Default empty array.
     */
    public function end_el( &$output, $page, $depth = 0, $args = array() ) {

        $output .= "</li>\n";
    }



}

Nous voilà avec des boutons radios pour notre plugin !

Capture d’écran 2016-07-19 à 15.17.42

 

Vous pouvez retrouver tout le code source de cette partie du tutoriel dans la branch part-2 sur Github.

* Utiliser une fonction d’un plugin pour ses propres besoins

Je dédie cette petite étoile, faîte précédemment, car notre fonctionnalité, qui permet de créer des boutons radio au lieu de checkbox, peut être utilisée par tous.

C’est à dire que n’importe quel thème ou n’importe quel plugin pourrait décider de venir se hooker sur notre tableau de taxonomies pour créer / changer l’apparence de ces taxonomies au niveau des metabox d’une checkbox à un bouton radio.

On est tous d’accord pour dire que ce ne serait pas une bonne pratique puisque :

  1. Ce n’est pas le but de notre plugin. A la base, ce hook pourrait permettre à une personne de faire chemin inverse. Elle pourrait vouloir qu’une todo ait plusieurs State en même temps.
  2. On ne va pas faire installer ce plugin uniquement pour récupérer cette fonctionnalité.

Que faire ?

En ayant codé de cette manière, on ne peut que constater que ce genre de code doit :

  • Soit appartenir au core de WordPress. Cela demande donc un ticket, du temps et de défendre son bifteck. Puis de manière générale, ce ne serait pas implémenté de cette manière là dans le core.
  • Soit se trouver dans une librairie

En effet, nous pourrions isoler ce code en dehors de notre plugin et le mettre à part sous la forme d’une librairie. De fait, on pourrait l’implémenter avec composer pour charger cette fonctionnalité externe à notre plugin. Il ne suffit que d’une ligne de commande et d’en faire un bon usage. Le fait d’embarquer ensuite ce vendor n’est en rien contraignant puisqu’il n’est dépendant de personne si ce n’est que de lui-même ! (et de fonctionner uniquement sur WordPress forcément).


A vous de jouer

Sans le vouloir, j’ai oublié de gérer un cas dans l’imbrication de toutes ces class ! J’ai donc décidé de vous faire participer à ce tutoriel en vous invitant à faire une « code review ». L’erreur qui s’est « glissée » n’est en rien dangereuse pour le plugin. Le développeur sera alerté par une erreur PHP que je n’ai pas gérée lorsqu’il tentera de « jouer » avec… ! quelque chose :) Pas trop d’indices pour l’instant.

N’hésitez pas à commenter pour en parler et de proposer une pull request sur le repo GitHub. La pull request qui sera acceptée gagnera un petit quelque chose en retour !

Dans le cas où personne ne trouve, je ferais la mise à jour nécessaire lors de la prochaine partie du tutoriel.

Cet article a été mis à jour il y a 197 jours

Article écrit par Thomas

Software Engineer chez YurPlan et auteur de WP GoD

Grand passionné des technologies web et de la science de l’informatique, je ne me restreins pas à un seul langage / une seule technologie. Je passe d’abord par une approche conceptuelle des projets avant d’admettre quel langage faut-il utiliser.

Développeur PHP, JavaScript et Python. J’utilise AngularJS, ReactJS, Django, Symfony1-2-3 et WordPress. Je m’amuse avec BabylonJS. Je versionne avec Git. Je compile avec BrunchJS et je déploie avec Capistrano.

0 Commentaire

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

95c6cdc30fc92af8645c400b4376f1fc!!!!!!!!!!!!!!!!