WordPress Plugin Development using Boilerplate

Set up an effective WordPress plugin development environment with a local server, IDEs, editors, and a terminal, and choose a browser (Chrome or Firefox) for testing.

Install WordPress locally with WAMP by creating a WWW directory, downloading WordPress, creating a database and user, and configuring a virtual host to complete the installation.

Learn to build WordPress plugins by following WordPress coding standards. Use inline documentation and naming and licensing guidelines to keep code consistent and readable with code sniffer tools.

Install php code sniffer and WordPress coding standards on a local machine. Clone the relevant GitHub repos, configure and link the WordPress standards to code sniffer for project use.

Configure PhpStorm to enforce WordPress coding standards for your plugin project by installing PHP CodeSniffer, selecting the WordPress rule set, and validating code with inspections.

Learn core WordPress plugin concepts, including custom post types, meta boxes, and custom fields, plus plugin option settings pages, short codes, widgets, and the loading mechanism with actions and filters.

Create a custom post type for events with the WordPress plugin boilerplate. Add metaboxes and custom fields for start date, time, location, links, and taxonomy to categorize events.

Learn how shortcodes work in WordPress, including their syntax, attributes, and usage to insert social share icons, and explore building your own shortcode-enabled plugin with boilerplate.

Explore how WordPress plugins use the settings page to configure options, manage data with the settings API, and inspect the options table and serialized data in the database.

Explore how WordPress widgets power sidebars, headers, and footers through themes and plugins; inspect common widgets like search, recent posts, and archives, and learn drag-and-drop customization with widget options.

Learn how WordPress loads plugins by scanning plugins folder for files with a header comment and metadata. Discover how single-file and folder plugins are found and how depth affects scanning.

Discover how WordPress action hooks let plugins modify behavior without editing core, by registering callbacks with do_action at times like admin menu loading, using a tag, priority, and arguments.

Explore WordPress filter hooks and how apply_filters and add_filter modify post contents and other data via content filters in a boilerplate plugin.

Learn what a WordPress plugin boilerplate is as a standardized, object oriented foundation for high quality plugins, with well documented code, clear file organization, and WordPress API compliance.

Explore WordPress plugin boilerplate options by cloning a GitHub repo or using the boilerplate generator, then rename references to your plugin name and let the generator create the files.

Learn how to use the boilerplate to prepare a WordPress plugin for repository approval, focusing on how the plugin name drives the slug, directory name, and homepage.

Explore the structure of a WordPress plugin boilerplate, including license, uninstall, activation, and deactivation, and main plugin files, and how admin and public classes load dependencies and register hooks.

Learn how to define and use helper constants for a WordPress boilerplate plugin, including plugin name, version, and directory, updating main and constructor code, and wiring resources.

Learn how to register custom post types in a WordPress plugin using boilerplate, including arguments, labels, and common errors, with hands-on coding and templates for single and archive.

Register a custom post type with minimal code to appear in the WordPress admin, using an action hook, anonymous callback, and public and labels arguments with plugin boilerplate.

Discover how to register a custom post type and taxonomy in WordPress plugin development using the public class method, including actions, init hooking, and example code for books and gender.

Register a custom post type using a CPT class with init hooks, and create separate methods to register the post type and the books gender taxonomy in a boilerplate structure.

Explore why boilerplate is essential for WordPress plugin development, enforcing coding and documentation standards. See how a structured boilerplate enables clear file organization, reliability, and easier collaboration on plugins.

Register the books custom post type and general taxonomy, then use the activation hook to flush rewrite rules and fix 404s, ensuring front end access after plugin activation.

Override books custom post type template by filtering content and wrapping it in a div. Use a book-content.php with output buffering to return content and verify with template viewing plugins.

Explore how WordPress loads templates for a custom post type via the template hierarchy and query string, including how single templates are chosen and overridden by child themes.

Learn to load a single post type template in a WordPress plugin using a template loader, extending the loader class, and overriding single template parts with plugin templates.

Show how to override the books archive template with a plugin loaded template, enable the genre taxonomy, and refactor to avoid repetition using a single template loader instance for efficiency.

Explore building a WordPress plugin boilerplate workflow to display the books custom post type with a loop, a custom archive template, and a card-based layout using template parts.

Learn how to add custom fields to metaboxes for custom post types, save and retrieve them, and display the data on the front end using boilerplate hooks.

learn to add custom meta boxes to a books custom post type using boilerplate in a WordPress plugin, including hooks, callbacks, and display of meta fields.

Learn to move a meta box between Gutenberg and classic editors for a books post type, using context and priority, with a compatibility check for pre-5.0 WordPress.

Discover how to add a custom field to a WordPress metabox, render an input with a label, and save and retrieve the value using post meta in a boilerplate plugin.

Learn to secure WordPress post metadata by integrating nonce fields and nonce verification with wp_nonce_field, validating action names, and handling failures to prevent csrf attacks in custom post type forms.

Verify user capabilities and nonce to secure the save method for a custom post type meta box, preventing auto saves and ensuring only authorized users can update post data.

Learn to sanitize custom fields and escape output in WordPress plugin development to prevent script injection. Use sanitization functions to strip tags and escape output for safe rendering.

Explore validating and sanitizing custom fields in WordPress plugin boilerplate, focusing on numeric input for pages, boolean checkbox fields, and ensuring updates reflect only allowed yes/no values.

Learn to validate a WordPress select input for book format by comparing against an allowed values array (hardcover, audio, video). Apply validation over sanitization and update the post.

Learn to display post meta for a single book by loading a plugin template, cleaning the front-end layout, and rendering custom fields and the book image.

Display custom fields on the archive-book template by refactoring into a reusable template, iterating an array of keys and labels, and loading meta with safe, translatable output.

Improve WordPress plugin boilerplate by adding a single content title wrapped in an h1, and implement escaping, translation with __ and _e, and existence checks for Gutenberg and front-end display.

Learn to add Font Awesome icons to custom fields in a WordPress plugin by bundling assets locally, updating sources, and conditionally loading icons for single posts, archives, and taxonomies.

Explore helper frameworks for adding and managing WordPress metabox custom fields, focusing on CMB to and CMB too, and learn to integrate, render, and sanitize plugin settings.

Explore how helper frameworks and boilerplates accelerate WordPress plugin development by creating meta boxes with configurable fields, options, defaults, and sanitization, without writing extensive code.

Learn to create a WordPress plugin options settings page in the admin menu, using the settings API to display and save plugin options in a boilerplate plugin.

Add a top level admin menu to a WordPress plugin. Register admin_menu, implement add_menu_page with page title, menu title, capabilities, slug, and callback.

Move a top level plugin menu to a sub menu and learn to add sub menus to the settings or plugins menu using WordPress admin functions, with practical code adjustments.

Add a plugin settings page using a form post method and save options with WordPress options; compare the old technique with the settings api and discuss sanitization.

This lecture introduces using the WordPress settings API to display sections, add sections and settings fields, and save or register the settings, with security via an options group.

Implement the settings API to add a general settings section on the plugin options page by defining id, title, description, and page with a callback, and hook it into admin_init.

Create and render settings fields in a WordPress plugin using the Settings API, specifying id, title, callback, page, and section, then display inputs within the chosen section.

Save settings with the WordPress settings API by registering the setting, naming the option and group, and retrieving and escaping the value on the settings page.

Add admin settings sections to a WordPress plugin, register and sanitize fields with the Settings API, implement validation callbacks, and display save messages for better user experience.

Learn how to use the settings API to render settings fields with a class-based callback, pass argument arrays, and safely display field values in a WordPress plugin.

Add a select field to the WordPress plugin boilerplate settings to choose the archive page column count. Learn to configure options, handle callbacks, and reflect the chosen columns on the books archive.

Explore using a settings option to control archive column counts for a books custom post type, applying the chosen value via get_option and a default fallback.

Demonstrate creating WordPress plugin action links by adding a settings field and a select markup, using a checked callback, and wiring admin hooks and filters to show settings.

Explore popular WordPress plugin and theme frameworks, including CMB2, the red X framework, Kosta, coaster framework, freemium framework, and options framework, evaluating options for metaboxes, custom fields, and plugin settings.

Learn to add a WordPress plugin admin menu and settings sections using a helper class, including cloning a vendor library, registering menu items, and configuring sections and pages.

Add basic settings fields in a WordPress plugin using boilerplate, including text and select fields for general and airlines, then save, reload, and verify population via the settings API.

Explore a helper class to implement advanced field types and action links in WordPress plugin development. Configure text, color, number, textarea, and file fields with tab navigation and sanitize callbacks.

Create a global shared class with static methods to house common functionality for all classes, wiring it into the plugin dependencies to avoid rewriting code.

Create a global template loader in the plugin by converting the loader to a protected static property that initializes once and is reusable across post types, widgets, and other classes.

Create a centralized helper functions file for a WordPress plugin, define prefixed utility functions to detect singular, archive, or taxonomy pages, and reuse them across code.

Learn to build WordPress plugins with boilerplate: add a shortcode via a guard function, create a dedicated class, set default attributes, and build shortcodes for custom post type loops.

Learn how the WordPress add_shortcode API works by defining a shortcode with a tag and callback, handling attributes and content, and returning output rather than echoing it.

Create a dedicated shortcode class to handle shortcodes in a WordPress plugin, reuse an existing class, define dependencies, and implement a book list shortcode with attributes and content.

Create a book list shortcode that displays a custom post type loop for books by reusing archive code, using wp query with arguments, and returning markup via a template part.

Configure shortcode output by using attributes to set a default limit and override it with user input. Use WordPress defaults and site options for post limits when none are provided.

Learn to control shortcode output by adding a column attribute in a WordPress plugin boilerplate, mapping values to CSS classes, and defaulting to three columns.

Apply a shortcode attribute to set the cards' background color in a WordPress plugin using boilerplate, update the grid display, and explore methods to implement color changes.

Learn to add css via a style tag in a WordPress plugin, applying class-based styles to elements while sanitizing color values to avoid security risks and ensure safe, dynamic styling.

Apply a four-step process to enqueue css and js for shortcodes in WordPress: register a placeholder style, build assets, attach them to the placeholder, and update the style.

Refactor and optimize enqueuing css and js for the plugin by creating a dedicated method to assemble css assets and conditionally load them via a class property.

Register and enqueue styles and scripts in your plugin using WordPress functions, then enhance shortcodes to filter displayed books by a taxonomy slug with a custom WP_Query.

Learn to show custom post types for specific taxonomies in a WordPress plugin by configuring taxonomy arguments, default values, and comma-separated terms.

Register a widget using the widget API and build a class to manage widgets. Explore widget args and instance, and use form, update, and widget methods to alter output.

Create and register dedicated plugin widgets using WordPress widgets API by extending the WP_Widget class. Build a controller class to manage all widgets and hook into the three-step widget registration process.

Explore building a WordPress widget using boilerplate by creating and registering a widget class, implementing form, update, and widget methods, and configuring admin options for a books list widget.

Explore how the Widgets API uses args and instance data to render a books list in a WordPress sidebar, including before and after widget and title hooks.

Learn to use the widgets API form method to add fields to a WordPress widget, including a title input, handling IDs, names, and instances, and updating front-end output.

Learn to securely save widget fields in WordPress plugin development by using the update method to sanitize input and strip scripts, updating values like title and limit.

Learn to display a custom post type loop in a WordPress widget using a widget class, with loop arguments and a configurable limit, and render content via a widget template.

Enqueuing widget specific styles and scripts for a WordPress widget, conditionally loading assets when the widget is active, and adding a format select to filter books by format.

Add a select field for book formats in the widget format method. Build options, render output options, and update the widget loop to apply the chosen format.

learn to create a WordPress widget by extending the WP_Widget class, registering it, and implementing the widget, form, and update methods to display a feature book in the sidebar.

Add fields to the plugin using the helper class and a fields arguments array with automatic sanitization. Integrate color options with shortcodes and widgets and prepare a user-selectable post option.

Configure a widget to select a featured book from the books post type using a field array and shortcode logic to render the chosen book with a reusable helper class.