Note The package has been renamed in version 12, see the upgrade guide.

WordPlate

WordPlate is a boilerplate for WordPress websites, built with Composer and designed with sensible defaults.

• Features
• Installation
• Configuration
• Plugins
• Vite.js
• Mail
• FAQ
• Upgrade Guide
• Acknowledgements

Features

• WordPress + Composer = ♥️

  WordPress can be installed and updated with ease using Composer. To update WordPress, simply run the command composer update.

• Environment Files

  Similar to Laravel, WordPlate stores environment variables, such as database credentials, in an .env file.

• WordPress Packagist

  WordPress Packagist enables the management of WordPress plugins and themes through Composer.

• Must-use plugins

  Don't worry about clients deactivating plugins; must-use plugins are enabled by default.

• Vite.js

  Using Vite, you can rapidly set up and begin building and minifying your CSS and JavaScript.

• Debugging

  Familiar debugging helper functions are integrated such as dump() and dd().

• Clean UI

  Enhance the WordPress dashboard and improves the user experience for clients.

• Security

  We've replaced WordPress' outdated and insecure MD5-based password hashing with modern and secure bcrypt using the roots/wp-password-bcrypt package.

Installation

Before using WordPlate, make sure you have PHP 8.1 and MySQL 8.0 installed on your computer. You'll also need to have Composer, a package manager for PHP, installed on your computer.

To install WordPlate, open your terminal and enter the following command:

composer create-project --prefer-dist vinkla/wordplate example-app

After installing WordPlate, you'll need to update the database credentials in the .env file. This file is located in the root directory of your project. Open the file and update the following lines with your database credentials:

DB_NAME=database
DB_USER=username
DB_PASSWORD=password

To run your WordPlate application, you may serve it using PHP's built-in web server. Open your terminal and navigate to the public directory of your project. Then, enter the following command:

php -S 127.0.0.1:8000 -t public/

Finally, open your web browser and visit the following URLs to view your WordPlate application:

• http://127.0.0.1:8000/ - Your website.
• http://127.0.0.1:8000/wordpress/wp-admin - The administration dashboard.

Configuration

Public Directory

After installing WordPlate, you'll need to configure your web server's document or web root to be the public directory. This is where the main entry point for your application, index.php, is located.

By setting the public directory as your web server's document root, you ensure that all HTTP requests are routed through the front controller, which handles the requests and returns the appropriate responses.

This configuration helps to improve the security and performance of your application by preventing direct access to files outside of the public directory.

Environment Configuration

WordPlate makes it easy to manage different configuration values based on the environment where your application is running. For example, you may need to use a different database locally than you do on your production server.

To accomplish this, WordPlate uses the vlucas/phpdotenv PHP package. When you install WordPlate, a .env.example file is included in the root directory of your application. If you installed WordPlate via Composer, this file will automatically be renamed to .env. Otherwise, you should rename the file manually.

It's important to note that your .env file should not be committed to your application's source control. This is because each developer or server using your application may require a different environment configuration. Additionally, committing your .env file to source control would be a security risk in the event that an intruder gains access to your repository, as any sensitive credentials would be exposed.

To learn more about managing environment variables in WordPlate, you can refer to Laravel's documentation on the topic:

• Environment Variable Types
• Retrieving Environment Configuration

Salt Keys

It's important to add salt keys to your environment file. These keys are used to encrypt sensitive data, such as user sessions, and help to ensure the security of your application.

If you don't set the salt keys, your user sessions and other encrypted data may be vulnerable to attacks. To make it easier to generate secure salt keys, we've created a salt key generator that you can use. If you haven't already done so, copy the .env.example file to a new file named .env. Then visit the generator and copy the randomly generated keys to your .env file.

Plugins

WordPress Packagist

WordPlate includes integration with WordPress Packagist, a Composer repository that mirrors the WordPress plugin and theme directories. With this integration, you can install and manage plugins using Composer.

To install a plugin, use wpackagist-plugin as the vendor name and the plugin slug as the package name. For example, to install the clean-image-filenames plugin, you would use the following command:

composer require wpackagist-plugin/clean-image-filenames

The installed packages will be located in the public/plugins directory.

Here's an example of what your composer.json file might look like:

"require": {
    "wpackagist-plugin/clean-image-filenames": "^1.3"
}

For more information and examples, please visit the WordPress Packagist website.

Must Use Plugins

Must-use plugins (also known as mu-plugins) are a type of WordPress plugin that is installed in a special directory inside the content folder. These plugins are automatically enabled on all sites in the WordPress installation.

To install plugins into the mu-plugins directory, add the plugin name to the installer-paths of your composer.json file:

"installer-paths": {
    "public/mu-plugins/{$name}": [
        "type:wordpress-muplugin",
        "wpackagist-plugin/clean-image-filenames",
    ]
}

To install the plugin, use wpackagist-plugin as the vendor name and the plugin slug as the package name:

composer require wpackagist-plugin/clean-image-filenames

The plugin will be installed in the public/mu-plugins directory.

For more information on the must-use plugin autoloader, please refer to the Bedrock documentation.

Included Plugins

Headache

An easy-to-swallow painkiller plugin for WordPress. It is included by default in WordPlate. It removes a lot of default WordPress stuff you just can't wait to get rid of. It removes meta tags such as feeds, version numbers and emojis.

Clean Image Filenames

The plugin automatically converts language accent characters in filenames when uploading to the media library. Characters are converted into browser and server friendly, non-accent characters.

• Räksmörgås.jpg → raksmorgas.jpg
• Æblegrød_FTW!.gif → aeblegrod-ftw.gif
• Château de Ferrières.png → chateau-de-ferrieres.png

Vite.js

Vite is a build tool that aims to provide a faster and leaner development experience for modern web projects. Vite is opinionated and comes with sensible defaults out of the box, but is also highly extensible via its Plugin API and JavaScript API with full typing support.

# Start the dev server...
npm run dev

# Build for production...
npm run build

To get started with Vite, please visit the documentation.

Mail

If you need to set up custom SMTP credentials for your WordPlate application, you can add the necessary code to your functions.php file. This file is located in the theme directory of your WordPlate project and contains PHP functions that are loaded by WordPress during runtime. By adding the appropriate code to this file, you can configure your application to use custom SMTP credentials for sending emails.

use PHPMailer\PHPMailer\PHPMailer;

// Register SMTP email with HTML support.
add_action('phpmailer_init', function (PHPMailer $mail) {
    $mail->isSMTP();
    $mail->SMTPAutoTLS = false;
    $mail->SMTPAuth = env('MAIL_USERNAME') && env('MAIL_PASSWORD');
    $mail->SMTPSecure = env('MAIL_ENCRYPTION', 'tls');
    $mail->Host = env('MAIL_HOST');
    $mail->Port = env('MAIL_PORT', 587);
    $mail->Username = env('MAIL_USERNAME');
    $mail->Password = env('MAIL_PASSWORD');
    return $mail;
});

add_filter('wp_mail_content_type', fn () => 'text/html');
add_filter('wp_mail_from_name', fn () => env('MAIL_FROM_NAME', 'Example'));
add_filter('wp_mail_from', fn () => env('MAIL_FROM_ADDRESS', '[email protected]'));

Next, you'll need to add the necessary environment variables to your .env file:

MAIL_FROM_ADDRESS=
MAIL_FROM_NAME=
MAIL_HOST=
MAIL_PASSWORD=
MAIL_PORT=
MAIL_USERNAME=

If you're using a local email service like MailHog, you may need to disable encryption by setting the MAIL_ENCRYPTION environment variable to null:

MAIL_ENCRYPTION=null

FAQ

define('WP_DISABLE_FATAL_ERROR_HANDLER', env('WP_DISABLE_FATAL_ERROR_HANDLER', false));

+define('WP_ALLOW_MULTISITE', env('WP_ALLOW_MULTISITE', true));

WP_DEFAULT_THEME=wordplate
+WP_ALLOW_MULTISITE=true

<?php

namespace Valet\Drivers\Custom;

use Valet\Drivers\BasicValetDriver;

class WordPlateValetDriver extends BasicValetDriver
{
    public function serves(string $sitePath, string $siteName, string $uri): bool
    {
        return is_dir($sitePath . '/public/wordpress');
    }

    public function isStaticFile(string $sitePath, string $siteName, string $url)
    {
        $staticFilePath = $sitePath . '/public' . $url;

        if ($this->isActualFile($staticFilePath)) {
            return $staticFilePath;
        }

        return false;
    }

    public function frontControllerPath(string $sitePath, string $siteName, string $uri): ?string
    {
        return parent::frontControllerPath(
            $sitePath . '/public',
            $siteName,
            $this->forceTrailingSlash($uri)
        );
    }

    private function forceTrailingSlash(string $uri)
    {
        if (substr($uri, -1 * strlen('/wordpress/wp-admin')) === '/wordpress/wp-admin') {
            header('Location: ' . $uri . '/');
            exit;
        }

        return $uri;
    }
}

Upgrade Guide

Acknowledgements

WordPlate wouldn't be possible without these amazing open-source projects.

• composer/installers
• motdotla/dotenv
• outlandish/wpackagist
• roots/bedrock-autoloader
• roots/wordpress
• roots/wp-password-bcrypt
• symfony/http-foundation
• symfony/var-dumper
• upperdog/clean-image-filenames
• vinkla/headache
• vitejs/vite
• vlucas/phpdotenv

License

The WordPlate package is open-sourced software licensed under the MIT license.