Deploy WordPress Updates from a Private Repository

To push code to a private repository and trigger a pending WordPress update badge, you need to follow a systematic approach involving version control, continuous integration/deployment, and the appropriate use of WordPress hooks and filters. Here’s a step-by-step guide to accomplish this:

Step 1: Set Up Your Private Repository

1. Create a Repository:

   • On platforms like GitHub, GitLab, or Bitbucket, create a new private repository.
   • Clone the repository to your local machine using git clone.

2. Organize Your Plugin Files:

   • Ensure your WordPress plugin files are structured correctly in the local repository.
   • Follow the standard WordPress plugin file structure.

Step 2: Update Version and Push Code

1. Update Plugin Version:

   • In your plugin's main file, update the version number in the plugin header comment.
   • Example:

     /*
     Plugin Name: My Plugin
     Plugin URI: https://example.com/
     Description: A description of my plugin.
     Version: 1.1.0
     Author: Your Name
     Author URI: https://example.com/
     License: GPL2
     */
     

2. Commit and Push Changes:

   • Add, commit, and push your changes to the repository:

     git add .
     git commit -m "Update plugin to version 1.1.0"
     git push origin main
     

Step 3: Configure Webhooks for CI/CD

To automate the deployment process and trigger the update badge, you need to set up continuous integration and deployment (CI/CD) using webhooks.

1. Set Up CI/CD Pipeline:

   • Use a service like GitHub Actions, GitLab CI/CD, or Bitbucket Pipelines to set up a pipeline that triggers on push events.

   • Example GitHub Actions workflow (.github/workflows/deploy.yml):

     name: Deploy Plugin
     
     on:
       push:
         branches:
           - main
     
     jobs:
       build:
         runs-on: ubuntu-latest
     
         steps:
         - name: Checkout code
           uses: actions/checkout@v2
     
         - name: Deploy to WordPress
           run: |
             # Add deployment scripts here, for example:
             # scp -r ./my-plugin user@server:/path/to/wordpress/wp-content/plugins/
             echo "Deploying plugin to WordPress..."
     

Step 4: Create a Custom Endpoint to Check for Updates

To display the update badge in the WordPress admin area, you need to create a custom endpoint that WordPress can query to check for updates.

1. Create an Endpoint:

   • Host an endpoint on your server or use a cloud function service.
   • The endpoint should return the latest version and other update information in JSON format.

   Example PHP code for a custom update server:

   add_action('rest_api_init', function () {
       register_rest_route('my-plugin/v1', '/update-check', [
           'methods' => 'GET',
           'callback' => 'my_plugin_update_check',
       ]);
   });
   
   function my_plugin_update_check() {
       return new WP_REST_Response([
           'version' => '1.1.0',
           'url' => 'https://example.com/my-plugin.zip',
           'requires' => '5.0',
           'tested' => '5.7',
           'requires_php' => '7.2',
       ]);
   }
   

Step 5: Modify Your Plugin to Check for Updates

Modify your plugin to check for updates from your custom endpoint and trigger the update badge.

1. Add Update Checker:

   • Use a library like the Plugin Update Checker to check for updates.

   • Example:

     require 'path/to/plugin-update-checker/plugin-update-checker.php';
     
     $updateChecker = Puc_v4_Factory::buildUpdateChecker(
         'https://example.com/wp-json/my-plugin/v1/update-check',
         __FILE__,
         'my-plugin'
     );
     
     $updateChecker->setAuthentication('your-secret-key');
     

Step 6: Test the Entire Process

1. Trigger an Update:

   • Push a new version to your repository.
   • Ensure the CI/CD pipeline deploys the update correctly.

2. Check for Updates in WordPress:

   • Log in to your WordPress admin area.
   • Navigate to Plugins and see if the update badge appears for your plugin.

By following these steps, you can successfully push code to a private repository, deploy the updates, and trigger a pending update badge in WordPress. This approach leverages version control, CI/CD pipelines, and custom update mechanisms to ensure smooth and secure plugin updates.