Stars: 1977
Forks: 156
Pull Requests: 211
Issues: 160
Watchers: 53
Last Updated: 2023-08-26 14:33:03
WordPlate is a boilerplate for WordPress, built with Composer and designed with sensible defaults.
License:
Languages: PHP, CSS, JavaScript, Shell
Note The package has been renamed in version 12, see the upgrade guide.
WordPlate is a boilerplate for WordPress, built with Composer and designed with sensible defaults.
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.
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.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.
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:
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.
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 (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.
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.
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.
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.
To configure custom SMTP credentials for sending emails in your WordPlate application, add the following code to your functions.php
file.
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
This is possible by updating the public/wp-config.php
file after the WordPlate application have been created.
define('WP_DISABLE_FATAL_ERROR_HANDLER', env('WP_DISABLE_FATAL_ERROR_HANDLER', false));
+define('WP_ALLOW_MULTISITE', env('WP_ALLOW_MULTISITE', true));
Then you may add the constant to the .env
file.
WP_DEFAULT_THEME=wordplate
+WP_ALLOW_MULTISITE=true
If you want to install language packs using Composer, we recommend looking at the WP Languages project.
Update your .gitignore
, composer.json
, .vite.config.js
, and wp-cli.yml
files with the new path to the public
directory. Then, run composer update
in the root of your project.
By default WordPlate will put the WordPress in public/wordpress
. If you want to change this there are a couple of steps you need to go through. Let's say you want to change the default WordPress location to public/wp
:
Update the wordpress-install-dir
path in your composer.json
file.
Update wordpress
to wp
in wordplate/public/.gitignore
.
Update the last line in the public/index.php
file to:
require __DIR__.'/wp/wp-blog-header.php';
Update the WP_DIR
environment variable in the .env
file to wp
.
If you're using WP-CLI, update the path in the wp-cli.yml
file to public/wp
.
Remove the public/wordpress
directory if it exist and then run composer update
.
For most applications you may leave the theme directory as it is. If you want to rename the wordplate
theme to something else you'll also need to update the WP_DEFAULT_THEME
environment variable in the .env
file.
If you're using Laravel Valet together with WordPlate, you may use our custom valet driver:
<?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;
}
}
The wordplate/framework
package has been archived. Update the composer.json
file:
"require": {
- "wordplate/framework": "^11.1",
+ "composer/installers": "^2.1",
+ "johnpbloch/wordpress-core-installer": "^2.0",
+ "johnpbloch/wordpress-core": "^6.0",
+ "roots/bedrock-autoloader": "^1.0",
+ "roots/wp-password-bcrypt": "^1.1",
+ "symfony/http-foundation": "^6.0",
+ "symfony/var-dumper": "^6.0",
+ "vlucas/phpdotenv": "^5.4"
}
Replace your public/wp-config.php
file with the one in this repository. Remember to save any custom constants defined in your wp-config.php
file.
Add the src/helpers.php
file from this repository and autoload it in the composer.json
file:
+"autoload": {
+ "files": [
+ "src/helpers.php"
+ ]
+}
Run composer update
in the root of your project.
WordPlate now requires PHP 8.0 or later.
Bump the version number in the composer.json
file to ^11.0
.
Run composer update
in the root of your project.
WordPlate now requires PHP 7.4 or later.
Bump the version number in the composer.json
file to ^10.0
.
Rename WP_ENV
to WP_ENVIRONMENT_TYPE
in the environment file.
Rename WP_THEME
to WP_DEFAULT_THEME
in the environment file.
Rename WP_URL
to WP_HOME
in the environment file (if it exists).
If you're using the WP_CACHE
environment variable you'll need to define it in the public/wp-config.php
file:
$application->run();
+define('WP_CACHE', env('WP_CACHE', false));
$table_prefix = env('DB_TABLE_PREFIX', 'wp_');
Optional: Rename WP_PREFIX
to DB_TABLE_PREFIX
in the following files:
.env
.env.example
public/wp-config.php
Run composer update
in the root of your project.
Bump the version number in the composer.json
file to ^9.0
.
Copy the public/mu-plugins/mu-plugins.php
file into your project.
Update the public/.gitignore
file to allow the new mu-plugins.php
file:
-mu-plugins/
+mu-plugins/*
+!mu-plugins/mu-plugins.php
Run composer update
in the root of your project.
WordPlate now requires PHP 7.2 or later.
Bump the version number in the composer.json
file to ^8.0
.
Note: WordPlate 8.0 requires WordPress 5.3 or later.
Laravel's helper functions is now optional in WordPlate. If you want to use the functions, install the laravel/helpers
package, with Composer, in the root of your project:
composer require laravel/helpers
Laravel's collections are now optional in WordPlate. If you want to use collections, install the tightenco/collect
package, with Composer, in the root of your project:
composer require tightenco/collect
The mix
helper function is now optional in WordPlate. If you want to use the function, install the ibox/mix-function
package, with Composer, in the root of your project:
composer require ibox/mix-function
Replace any usage of asset
, stylesheet_url
and template_url
functions with WordPress's get_theme_file_uri
function.
Replace any usage of stylesheet_path
and template_path
functions with WordPress's get_theme_file_path
function .
The base_path
and template_slug
functions have been removed.
Run composer update
in the root of your project.
Bump the version number in the composer.json
file to ^7.0
.
Note: WordPlate 7.0 requires WordPress 5.0 or later.
Update the realpath(__DIR__)
to realpath(__DIR__.'/../')
in the wp-config.php
file.
If your public directory isn't named public
, add the following line to the wp-config.php
file:
$application->setPublicPath(realpath(__DIR__));
Run composer update
in the root of your project.
Bump the version number in the composer.json
file to ^6.0
.
Update the realpath(__DIR__.'/../')
to realpath(__DIR__)
in the wp-config.php
file.
Run composer update
in the root of your project.
Bump the version number in the composer.json
file to ^5.0
.
Copy and paste the contents of the wp-config.php
file into your application.
Note: Make sure you don't overwrite any of your custom constants.
Run composer update
in the root of your project.
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
The WordPlate package is open-sourced software licensed under the MIT license.