In the previous post of the WordPress Plugin Boilerplate series, we walked through the structure. We also examined each file and what they do. The biggest feature of the version 3 rewrite is the new loader class.
The loader class loops through all the hook calls and registers them with WordPress all at once. The class consists of two class variables and four methods.
Each of the class variables are arrays containing the hooks and their corresponding functions.
An array of the all actions to register with WordPress.
An array of the all the filters to register with WordPress.
There are only four methods in the loader class, not counting the constructor.
The class constructor simply assigns a blank array to each of those class variables.
Adds the action passed to it to the $actions class variable using the add() method.
Adds the filter passed to it to the $filters class variable using the add() method.
Takes the passed in hook and the other parameters and restructures everything into an array.
Loops through the $actions and $filters class variables and registers each hook with WordPress.
The main plugin class calls add_action() and add_filter() with the hook parameters. Each method passes parameters to the add() method, which collects all the hooks into respective class variables. The main plugin class calls the run() method, loops through the class variables, then registers the hooks with WordPress.
How to Register Hooks
The most confusing part of using the new loader class is properly registering hooks. While the boilerplate has methods named add_action() and add_filter(), they work differently than the WordPress functions.
The boilerplate gathers all the hooks to register them with WordPress all at once. Let’s use the enqueue_styles declaration in define_admin_hooks() as an example.
First, we have to create an instance of the admin class and assign it as the variable $plugin_admin. We also pass the plugin_name and version using the get_plugin_name() and get_version() methods in this class.
$plugin_admin = new Plugin_Name_Admin($this->get_plugin_name(), $this->get_version());
Next, we use the add_action method in the Loader instance. Each hook registers separately with the loader class. In the load_dependencies() method, we assigned the instantiated loader class to the $loader class variable.
Since enqueue_styles is an action hook, we use the add_action() method from the loader class.
This first parameter of the boilerplate’s add_action method is the name of the hook. In this case, admin_enqueue_scripts.
The second parameter of the add_action method is the class instance of our action.
Finally, we put the name of the method in the class where WordPress can find our action. In this case, the name of the method is enqueue_styles.
$this->loader->add_action('admin_enqueue_scripts', $plugin_admin, 'enqueue_styles');
Additional Loader Method Parameters
The loader class accepts two additional parameters: the hook priority and the accepted arguments. Both are optional and in this case, we’re not using either. However, a complete example would be:
$this->loader->add_action('admin_enqueue_scripts', $plugin_admin, 'enqueue_styles', 10, 1);
Finally, in the admin class, the enqueue_styles() method contains:
wp_enqueue_style($this->plugin_name, plugin_dir_url(__FILE__) . 'css/plugin-name-admin.css', array(), $this->version, 'all');
This is the standard way to enqueue a CSS file into the WordPress admin through the plugin boilerplate methods.
We have seen how the loader class works and the proper way to register a hook.
In future posts, we will learn how to create various plugin features using the boilerplate. Let’s start by creating the WP Starter Plugin by using the plugin generator.