Les plugins enfants ? Oui c’est possible !

Le dilemme du développeur

[article mis à jour le 24/10/2025]

En tant que développeur WordPress, vous connaissez bien cette situation frustrante : vous avez trouvé le plugin parfait pour votre client, mais il manque quelques fonctionnalités ou le comportement ne correspond pas exactement à ses besoins. Vous vous retrouvez alors face à un choix difficile :

• Modifier directement le code du plugin (mauvaise pratique)
• Renommer le plugin et accepter de ne jamais le mettre à jour
• Créer son plugin personnalisé

Heureusement, il existe une quatrième solution, souvent méconnue : les plugins enfants. Une agence WordPress peut implémenter cette solution (child plugins). Tout comme les thèmes enfants ont révolutionné la personnalisation des thèmes WordPress, les plugins enfants offrent une approche professionnelle et maintenable pour étendre les fonctionnalités d’un plugin existant.

Pourquoi les plugins enfants sont essentiels

Les risques de la modification directe

Modifier directement un plugin WordPress présente plusieurs problèmes critiques :

Perte de mises à jour de sécurité. Lorsqu’une faille de sécurité est découverte, l’éditeur du plugin publie une mise à jour. En renommant le plugin ou en modifiant directement son code, vous n’êtes plus notifié des mises à jour et votre site reste vulnérable. C’est un risque majeur pour la sécurité.

Maintenance compliquée. Après quelques mois ou années, vous oubliez ce que vous avez modifié. Quand vous devez intervenir à nouveau, c’est devenu un cauchemar de documentation et de suivi.

Rupture lors des mises à jour. Si vous oubliez de renommer le plugin, la prochaine mise à jour écrasera purement et simplement vos modifications, souvent au pire moment possible.

Absence de versioning. Sans un système de contrôle de version, vous ne disposez d’aucun historique de vos changements. Un bug s’est introduit ? Vous ne savez pas quand ni comment.

Comment les plugins enfants résolvent ces problèmes

Un plugin enfant fonctionne exactement comme un thème enfant : il peut surcharger ou étendre le comportement du plugin parent sans jamais le modifier. Les avantages sont immédiats :

• Continuité des mises à jour. Le plugin parent peut être mis à jour sans risque de perdre vos modifications.
• Séparation claire. Vos personnalisations sont isolées dans un plugin dédié, facile à identifier et maintenir.
• Flexibilité maximale. Vous pouvez modifier des fonctions, ajouter de nouvelles fonctionnalités, ou complètement ignorer certaines parties du plugin parent.
• Récupération rapide. Si quelque chose ne fonctionne pas, vous pouvez désactiver le plugin enfant en un clic.

Architecture d’un plugin enfant

Structure des fichiers

Un plugin enfant a une structure très simple :

mon-plugin-enfant/
├── mon-plugin-enfant.php
├── functions.php
└── readme.txt

Le fichier principal (mon-plugin-enfant.php)

C’est le fichier que WordPress charge pour initialiser le plugin enfant. Voici un exemple complet et commenté :

<?php
/**
 * Plugin Name: Mon Plugin Enfant - WooCommerce
 * Plugin URI: https://monsite.fr/plugins/mon-plugin-enfant
 * Description: Étend les fonctionnalités de WooCommerce pour notre boutique
 * Version: 1.0.0
 * Author: Mon Entreprise
 * Author URI: https://monsite.fr
 * License: GPL v2 or later
 * License URI: https://www.gnu.org/licenses/gpl-2.0.html
 * Text Domain: mon-plugin-enfant
 * Domain Path: /languages
 * Requires Plugins: woocommerce
 * Requires at least: 5.9
 * Requires PHP: 7.4
 */

// Vérifier que le plugin parent est actif
if ( ! is_plugin_active( 'woocommerce/woocommerce.php' ) ) {
    add_action( 'admin_notices', function() {
        echo '<div class="notice notice-error"><p>';
        echo esc_html__( 'Mon Plugin Enfant nécessite WooCommerce pour fonctionner.', 'mon-plugin-enfant' );
        echo '</p></div>';
    });
    return;
}

// Charger les fonctions du plugin enfant
require_once plugin_dir_path( __FILE__ ) . 'functions.php';

Points clés :

• Requires Plugins : indique le plugin parent requis (WordPress 6.2+)
• La vérification d’activation garantit que le plugin parent est actif
• Le chemin du fichier functions.php est défini de manière absolue et sûre

Le fichier functions.php

C’est ici que se trouvent toutes les modifications et extensions :

<?php
/**
 * Fonctions du plugin enfant WooCommerce
 */

// S'assurer que ce fichier n'est pas appelé directement
if ( ! defined( 'ABSPATH' ) ) {
    exit;
}

/**
 * Modifier le prix des produits
 * Ajouter une remise de 10% à tous les produits
 */
add_filter( 'woocommerce_get_price', function( $price, $product ) {
    if ( is_product() ) {
        $price = $price * 0.9; // 10% de réduction
    }
    return $price;
}, 10, 2 );

/**
 * Ajouter un champ personnalisé au formulaire de commande
 */
add_filter( 'woocommerce_checkout_fields', function( $fields ) {
    $fields['billing']['company']['required'] = true;
    $fields['billing']['company']['class'] = array( 'form-row-wide' );
    return $fields;
});

/**
 * Modifier le message de stock
 */
add_filter( 'woocommerce_get_availability_text', function( $text, $product ) {
    if ( $product->get_stock_quantity() < 5 && $product->get_stock_quantity() > 0 ) {
        return __( 'Seulement quelques unités restantes !', 'mon-plugin-enfant' );
    }
    return $text;
}, 10, 2 );

/**
 * Remplacer un template du plugin parent
 * WooCommerce cherchera d'abord dans le dossier templates du plugin enfant
 */
add_filter( 'woocommerce_locate_template', function( $template, $template_name, $template_path ) {
    $child_template = plugin_dir_path( __FILE__ ) . 'templates/' . $template_name;

    if ( file_exists( $child_template ) ) {
        return $child_template;
    }

    return $template;
}, 10, 3 );

 

Cas d’usage pratiques

Cas 1 : Modifier le comportement d’un filtre WooCommerce

Imaginons que vous souhaitiez créer un plugin basé sur WooCommerce mais que vous vouliez modifier comment les taxes sont calculées pour certaines catégories:

add_filter( 'woocommerce_product_get_price', function( $price, $product ) {
    // Ne modifier le prix que pour la catégorie "Promotions"
    if ( has_term( 'promotions', 'product_cat', $product->get_id() ) ) {
        $price = $price * 0.85; // 15% de réduction
    }
    return $price;
}, 10, 2 );

Cas 2 : Ajouter une action personnalisée après une commande

Vous voulez envoyer une notification Slack ou une action personnalisée après chaque commande :

add_action( 'woocommerce_order_status_completed', function( $order_id ) {
    $order = wc_get_order( $order_id );

    // Appel API ou action personnalisée
    wp_remote_post( 'https://api.slack.com/hooks/...', array(
        'method'      => 'POST',
        'timeout'     => 45,
        'redirection' => 5,
        'httpversion' => '1.0',
        'blocking'    => true,
        'headers'     => array(
            'Content-Type' => 'application/json',
        ),
        'body'        => json_encode( array(
            'text' => 'Nouvelle commande : ' . $order->get_order_number(),
        )),
    ));
});

 

Cas 3 : Remplacer les templates du plugin parent

Vous voulez modifier l’affichage d’une page du plugin parent. Créez une structure de dossiers qui correspond :

mon-plugin-enfant/
├── mon-plugin-enfant.php
├── functions.php
└── templates/
    └── woocommerce/
        └── single-product.php

Le contenu de templates/woocommerce/single-product.php peut être une copie modifiée du fichier original, ou un fichier complètement nouveau.

Cas 4 : Ajouter des settings d’administration

Créez une page d’options pour permettre à l’utilisateur de configurer le plugin enfant :

add_action( 'admin_menu', function() {
    add_submenu_page(
        'woocommerce',
        'Paramètres - Plugin Enfant',
        'Plugin Enfant',
        'manage_options',
        'mon-plugin-enfant-settings',
        'mon_plugin_enfant_settings_page'
    );
});

function mon_plugin_enfant_settings_page() {
    ?>
    <div class="wrap">
        <h1><?php _e( 'Paramètres du Plugin Enfant', 'mon-plugin-enfant' ); ?></h1>
        <form method="post" action="options.php">
            <?php settings_fields( 'mon-plugin-enfant-settings' ); ?>
            <?php do_settings_sections( 'mon-plugin-enfant-settings' ); ?>
            <?php submit_button(); ?>
        </form>
    </div>
    <?php
}

// Enregistrer les settings
add_action( 'admin_init', function() {
    register_setting( 'mon-plugin-enfant-settings', 'mon_plugin_enfant_reduction' );

    add_settings_section(
        'mon-plugin-enfant-general',
        __( 'Paramètres généraux', 'mon-plugin-enfant' ),
        function() {
            echo 'Configurez les options du plugin enfant ici.';
        },
        'mon-plugin-enfant-settings'
    );

    add_settings_field(
        'mon_plugin_enfant_reduction',
        __( 'Pourcentage de réduction (%)', 'mon-plugin-enfant' ),
        function() {
            $value = get_option( 'mon_plugin_enfant_reduction', 10 );
            echo '<input type="number" name="mon_plugin_enfant_reduction" value="' . intval( $value ) . '" min="0" max="100" />';
        },
        'mon-plugin-enfant-settings',
        'mon-plugin-enfant-general'
    );
});

Techniques avancées

Charger les ressources (CSS et JavaScript)

add_action( 'wp_enqueue_scripts', function() {
    wp_enqueue_style( 
        'mon-plugin-enfant-style',
        plugin_dir_url( __FILE__ ) . 'css/style.css',
        array(),
        '1.0.0'
    );

    wp_enqueue_script(
        'mon-plugin-enfant-script',
        plugin_dir_url( __FILE__ ) . 'js/script.js',
        array( 'jquery' ),
        '1.0.0',
        true
    );
});

Internationalisation (i18n)

Pour rendre votre plugin traduisible :

add_action( 'plugins_loaded', function() {
    load_plugin_textdomain(
        'mon-plugin-enfant',
        false,
        dirname( plugin_basename( __FILE__ ) ) . '/languages'
    );
});

Utiliser les hooks WordPress correctement

// Les trois types de hooks :

// 1. Filters - Modifient une valeur et la retournent
add_filter( 'the_content', function( $content ) {
    return $content . '<p>Ajout personnalisé</p>';
});

// 2. Actions - Exécutent une action à un moment spécifique
add_action( 'woocommerce_thankyou', function( $order_id ) {
    // Action après remerciement de commande
});

// 3. Remover des hooks du plugin parent
remove_action( 'woocommerce_single_product', 'woocommerce_template_single_price' );
remove_filter( 'the_content', 'woocommerce_single_product' );

 

Bonnes pratiques

1. Toujours vérifier que le plugin parent existe

if ( ! function_exists( 'is_woocommerce' ) ) {
    wp_die( 'WooCommerce n\'est pas actif.' );
}

 

2. Utiliser des namespaces pour éviter les conflits

namespace MonEntreprise\PluginEnfant;

class ProductModifier {
    public function __construct() {
        add_filter( 'woocommerce_get_price', array( $this, 'modifier_prix' ), 10, 2 );
    }

    public function modifier_prix( $price, $product ) {
        return $price * 0.9;
    }
}

new ProductModifier();

 

3. Documenter vos modifications

/**
 * Modifier le calcul des frais de port
 * 
 * @param float $cost Coût original
 * @param int   $qty  Quantité de produits
 * @return float Coût modifié
 * @since 1.0.0
 */
add_filter( 'woocommerce_shipping_cost', function( $cost, $qty ) {
    // Logique personnalisée
    return $cost;
}, 10, 2 );

 

4. Versioner votre plugin enfant

Utilisez le semantic versioning :

• 1.0.0 → version de départ
• 1.0.1 → correction de bug
• 1.1.0 → nouvelle fonctionnalité
• 2.0.0 → changement majeur

5. Utiliser Git pour le contrôle de version

git init
git add .
git commit -m "Initial commit - plugin enfant WooCommerce"

Outils et ressources

WordPress Child Plugin Tool (GitHub)

Le projet wordpress-child-plugin-tool de Thomas Depole offre un framework complet pour créer des plugins enfants. Il automatise une grande partie du travail.

Hooks de WordPress

Consultez la documentation officielle :

• Hooks WordPress
• Plugin Handbook

Hooks de WooCommerce

Consultez la documentation « maison » :

• Hooks WooCommerce

On vous concocté une documentation, catégorisant les hooks et fonctions avec un exemple d’utilisation.
Plus de 9000 pages (!) regroupées par thème, et en accès libre. Merci qui ?

Conclusion

Les plugins enfants sont une meilleure pratique souvent oubliée qui devrait être utilisée bien plus largement dans l’écosystème WordPress. Ils offrent une solution élégante, sûre et maintenable pour personnaliser les plugins sans risque.

En adoptant cette approche, vous garantissez :

• La sécurité de votre site avec des mises à jour continues
• La maintenabilité du code pour vous-même et vos collègues
• La flexibilité pour adapter les plugins à vos besoins précis
• Une meilleure relation avec vos clients, qui bénéficient d’un site toujours à jour

La prochaine fois que vous pensez « je vais modifier ce plugin juste cette fois », créez plutôt un plugin enfant. Vous remercierez votre moi du futur.