In the vast world of web development, WordPress powers a significant portion of the digital realm. Yet, the traditional path of WordPress development, while familiar, is fraught with the tangled webs of version control and environment inconsistencies. It’s here that Bedrock emerges as a tool to help you keep your codebase more organized.

The Old, Not So Good Times

The traditional pains of WordPress development—be it the mess of vendor files in version control or the challenge of environment discrepancies—are elegantly addressed by Bedrock. Its structure not only simplifies the Git workflow but also sets a new standard for WordPress development, where clarity and efficiency reign supreme.

In traditional WordPress development, the journey often leads to a repository full of vendor files, that is, files from this parties (WordPress itself, unmodified plugins downloaded as they are from the WordPress Plugin Repository, etc). This happens because of the practice of directly incorporating plugins and themes into the project’s codebase.

As WordPress vanilla itself does not inherently include a built-in mechanism for managing these dependencies outside of the core installation and the whole project, developers are left with no choice but to manually include these plugins and themes, along with their updates, within their version control, or to find often clumsy alternatives. This standard practice, while straightforward, casts a shadow over the repository, cluttering it with a multitude of files are necessary for functionality, but go against clarity and efficiency.

It’s within this context that Bedrock shines as it enhances organization and simplicity. By leveraging Composer, Bedrock offers an elegant solution to this, allowing for the declaration of plugins and themes as dependencies. This shift not only clears the repository of the unnecessary weight of vendor files but also introduces a streamlined process for updates and management, ensuring that the focus remains on the development itself, not the cumbersome management of dependencies.

Composer, the PHP package manager, plays as it normally does the role of the conductor inside the context of Bedrock, orchestrating the various components that bring a project to life. For those venturing beyond the traditional WordPress realm, Composer might seem like a new territory. At its core is a dependency management tool for PHP that automates the inclusion of software packages, ensuring that you’re always using the latest versions of the tools you need, without having to manually track and update each package.

By declaring the packages your project depends on in a simple JSON file, Composer handles the rest, installing and updating them as required. This streamlines workflow, reduces errors, and significantly improves project maintainability. For WordPress developers looking to elevate their projects, understanding and utilizing Composer isn’t just an upgrade—it’s a transformation towards modern, efficient development practices.

Composing Your Git Repo The Right Way

The integration of Composer into WordPress development, as facilitated by Bedrock, fundamentally reshapes the way developers interact with Git, propelling adherence to best practices in version control. In a traditional WordPress setup, the necessity of tracking every plugin and theme within the Git repository not only inflates the repository size but also introduces a high degree of clutter and complexity. Each update, addition, or removal of a WordPress component requires manual handling within the Git workflow, leading to potential inconsistencies and a cumbersome management process.

With Composer in Bedrock’s approach, the inertia shifts away from manually tracking each file to a more holistic management of dependencies. This methodology allows for the delineation of plugins, themes, and the WordPress core itself within Composer’s framework, streamlining Git repositories by sidelining the bulk of third-party code. Plugins and themes are mentioned in composer.json file, yes, so that each person in the team can quickly deploy the project by just running composer install. But they are not included with all their files in the git repository, contrary to what happens with vanilla WordPress.

Such a refinement drastically cuts down on repository size, bringing into focus the substantial changes in a project’s proprietary code rather than being overshadowed by frequent updates to external components. This streamlined process is in harmony with Git’s best practices, ensuring repositories are leaner, collaboration is more streamlined, and the review process is significantly simplified.

WPackagist: The Composer Gateway for WordPress Themes and Plugins

WPackagist is the go-to resource for integrating WordPress into the Composer-managed environments, transforming how plugins and themes are handled. As a direct response to the challenge of marrying WordPress’s wide-ranging plugins and themes directory with Composer’s robust dependency management, WPackagist project (not directly affiliated with Bedrock) automatically replicates the WordPress repository in a format digestible by Composer.

This adaptation allows developers to manage WordPress components with precision, merging the convenience of Composer’s dependency resolution with the versatility of WordPress’s extensive ecosystem. By specifying WPackagist as a repository in their project’s composer.json, developers unlock the ability to include any WordPress plugin or theme as part of their Composer-managed dependencies, streamlining project setup and maintenance while adhering to best practices in version control.

WPackagist has become an indispensable tool for WordPress developers seeking a seamless integration with Composer’s ecosystem. Originating at the UK-based web development firm Outlandish and maintained collectively, WPackagist was created as an innovative solution to a longstanding inefficiency in WordPress development: the cumbersome process of managing plugins and themes.

Responding to the need for a more streamlined workflow, WPackagist now serves as a mirror to the WordPress plugin and theme directories, automatically converting these into formats compatible with Composer. This transformation allows for the precise management of WordPress components, blending the flexibility of WordPress’s extensive ecosystem with the efficiency of Composer’s dependency resolution. By incorporating WPackagist as a repository in a project’s composer.json, developers can directly request any WordPress plugin or theme, significantly simplifying project setup and maintenance.

In the context of a Bedrock project, integrating WordPress themes and plugins from the official repositories into your development workflow becomes a streamlined process, thanks to WPackagist. This approach leans heavily on the composer require command, which you use in conjunction with the wpackagist-theme or wpackagist-plugin prefix.

For instance, if you find a theme in the WordPress official repository you wish to include in your Bedrock project, you can easily add it using Composer by prefixing the theme’s slug with wpackagist-theme/. This command directly adds the theme as a dependency in your composer.json file and installs it in the appropriate directory within your project. The same methodology applies to plugins, where you prefix the plugin slug with wpackagist-plugin/ before running the composer require command.

The synergy between WPackagist and Bedrock further enhances this experience. While Bedrock structures WordPress development projects to be Composer-friendly, WPackagist ensures that themes and plugins from the WordPress repository are readily accessible as Composer packages. This dual approach not only declutters the Git repository by avoiding the direct inclusion of third-party code but also aligns with best practices in version control and project management.

A Twelve-Factor Approach to WordPress

There’s a very interesting intersection of Bedrock, WPackagist, and something called the Twelve-Factor App principles, a software development management methodology that Bedrock embraces, that helps move towards more sustainable, efficient, and scalable WordPress development practices. Let’s dissect a bit more how this intersection looks like in practice.

When we weave the threads of Bedrock’s structure and WPackagist’s repository management into the fabric of WordPress development, we not only enhance the Git workflow but also align closely with several key tenets of the Twelve-Factor methodology, particularly those related to codebase, dependencies, and configuration.

Bedrock’s approach to WordPress development ensures that a single codebase can be deployed to any number of environments with minimal friction. This is a core principle of the Twelve-Factor App, emphasizing the importance of version-controlled code that remains consistent across all stages of development. By managing themes and plugins via WPackagist and Composer, developers are further empowered to treat WordPress itself and its extensions as part of the project’s dependencies, ensuring that the entire application can be versioned and tracked with precision.

The traditional method of bundling plugins and themes directly within a WordPress project’s repository often leads to a bloated and unmanageable codebase. By utilizing Bedrock and WPackagist, dependencies are explicitly declared in a composer.json file, and the installation process is handled by Composer. This practice not only keeps the repository lean by avoiding the inclusion of third-party code but also ensures that dependencies are isolated and can be consistently installed across different environments, echoing the Twelve-Factor App’s call for explicit dependency management.

Also, Bedrock’s configuration system leverages environment variables for sensitive credentials and environment-specific settings, separating them from the code. This aligns with the Twelve-Factor methodology, which advocates for the strict separation of configuration from the codebase. Such a separation ensures that the application’s configuration can adapt to the environment it’s deployed in, without any changes to the code itself. This methodology not only simplifies the deployment process across diverse environments but also enhances security by keeping sensitive information out of version control.