Example: Cached Navigation Component

// File: cached_nav.php
<?php
/**
 * Renders a cached navigation menu
 * 
 * @param string $menu_location The menu location to render
 * @param int $cache_time Cache lifetime in seconds (default: 1 hour)
 * @return string The navigation HTML
 */
function get_cached_navigation($menu_location = 'primary', $cache_time = 3600) {
    // Create a unique cache key
    $cache_key = 'nav_' . $menu_location . '_' . md5(serialize(wp_get_current_user()));
    
    // Check if we have cached content
    $cached_html = get_transient($cache_key);
    
    if ($cached_html !== false) {
        return $cached_html;
    }
    
    // If no cache or expired, generate the navigation
    $html = '';
    
    // Build the navigation HTML
    $menu_args = [
        'theme_location' => $menu_location,
        'container' => 'nav',
        'container_class' => 'site-navigation',
        'menu_class' => 'nav-menu',
        'echo' => false,
    ];
    
    $html = wp_nav_menu($menu_args);
    
    // Store in cache
    set_transient($cache_key, $html, $cache_time);
    
    return $html;
}

/**
 * Clear navigation cache when menus are updated
 */
function clear_navigation_cache() {
    global $wpdb;
    
    // Delete all transients that start with 'nav_'
    $wpdb->query("DELETE FROM {$wpdb->options} WHERE option_name LIKE '_transient_nav_%'");
    $wpdb->query("DELETE FROM {$wpdb->options} WHERE option_name LIKE '_transient_timeout_nav_%'");
}

// Hook into menu updates to clear cache
add_action('wp_update_nav_menu', 'clear_navigation_cache');
?>
                    

Example: Database Component with Dependency Injection

// File: database_service.php
<?php
/**
 * Database configuration interface
 */
interface DatabaseConfig {
    /**
     * Get database host
     * 
     * @return string The database host
     */
    public function getHost();
    
    /**
     * Get database name
     * 
     * @return string The database name
     */
    public function getName();
    
    /**
     * Get database user
     * 
     * @return string The database user
     */
    public function getUser();
    
    /**
     * Get database password
     * 
     * @return string The database password
     */
    public function getPassword();
}

/**
 * WordPress database configuration implementation
 */
class WordPressDatabaseConfig implements DatabaseConfig {
    /**
     * Get database host
     * 
     * @return string The database host
     */
    public function getHost() {
        global $wpdb;
        return DB_HOST;
    }
    
    /**
     * Get database name
     * 
     * @return string The database name
     */
    public function getName() {
        return DB_NAME;
    }
    
    /**
     * Get database user
     * 
     * @return string The database user
     */
    public function getUser() {
        return DB_USER;
    }
    
    /**
     * Get database password
     * 
     * @return string The database password
     */
    public function getPassword() {
        return DB_PASSWORD;
    }
}

/**
 * Test environment database configuration
 */
class TestDatabaseConfig implements DatabaseConfig {
    /**
     * Get database host
     * 
     * @return string The database host
     */
    public function getHost() {
        return 'localhost';
    }
    
    /**
     * Get database name
     * 
     * @return string The database name
     */
    public function getName() {
        return 'test_db';
    }
    
    /**
     * Get database user
     * 
     * @return string The database user
     */
    public function getUser() {
        return 'test_user';
    }
    
    /**
     * Get database password
     * 
     * @return string The database password
     */
    public function getPassword() {
        return 'test_password';
    }
}

/**
 * Database service that uses dependency injection
 */
class DatabaseService {
    private $config;
    private $connection;
    
    /**
     * Constructor with injected dependency
     * 
     * @param DatabaseConfig $config The database configuration
     */
    public function __construct(DatabaseConfig $config) {
        $this->config = $config;
    }
    
    /**
     * Connect to the database
     * 
     * @return bool True if connected successfully
     */
    public function connect() {
        try {
            $this->connection = new PDO(
                'mysql:host=' . $this->config->getHost() . ';dbname=' . $this->config->getName(),
                $this->config->getUser(),
                $this->config->getPassword()
            );
            $this->connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            return true;
        } catch (PDOException $e) {
            error_log('Database connection failed: ' . $e->getMessage());
            return false;
        }
    }
    
    /**
     * Execute a query
     * 
     * @param string $query The SQL query
     * @param array $params Query parameters
     * @return array|false Results or false on failure
     */
    public function query($query, $params = []) {
        if (!$this->connection) {
            if (!$this->connect()) {
                return false;
            }
        }
        
        try {
            $statement = $this->connection->prepare($query);
            $statement->execute($params);
            return $statement->fetchAll(PDO::FETCH_ASSOC);
        } catch (PDOException $e) {
            error_log('Query failed: ' . $e->getMessage());
            return false;
        }
    }
}
?>
                    

Usage with Different Configurations

<?php
require_once 'database_service.php';

// Production environment
$productionConfig = new WordPressDatabaseConfig();
$productionDb = new DatabaseService($productionConfig);
$users = $productionDb->query('SELECT * FROM users WHERE active = ?', [1]);

// Test environment
$testConfig = new TestDatabaseConfig();
$testDb = new DatabaseService($testConfig);
$testUsers = $testDb->query('SELECT * FROM users WHERE active = ?', [1]);
?>
                    

Example: Simple Event System

// File: event_system.php
<?php
/**
 * Simple event management system
 */
class EventManager {
    private static $instance = null;
    private $listeners = [];
    
    /**
     * Get the singleton instance
     * 
     * @return EventManager The event manager instance
     */
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        
        return self::$instance;
    }
    
    /**
     * Add an event listener
     * 
     * @param string $event Event name
     * @param callable $callback Function to call when event is triggered
     * @param int $priority Priority (higher numbers run first)
     * @return void
     */
    public function addListener($event, $callback, $priority = 10) {
        if (!isset($this->listeners[$event])) {
            $this->listeners[$event] = [];
        }
        
        $this->listeners[$event][] = [
            'callback' => $callback,
            'priority' => $priority
        ];
        
        // Sort listeners by priority
        usort($this->listeners[$event], function($a, $b) {
            return $b['priority'] - $a['priority'];
        });
    }
    
    /**
     * Remove an event listener
     * 
     * @param string $event Event name
     * @param callable $callback Function to remove
     * @return bool True if listener was removed
     */
    public function removeListener($event, $callback) {
        if (!isset($this->listeners[$event])) {
            return false;
        }
        
        foreach ($this->listeners[$event] as $key => $listener) {
            if ($listener['callback'] === $callback) {
                unset($this->listeners[$event][$key]);
                $this->listeners[$event] = array_values($this->listeners[$event]);
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Trigger an event
     * 
     * @param string $event Event name
     * @param mixed $data Data to pass to listeners
     * @return void
     */
    public function trigger($event, $data = null) {
        if (!isset($this->listeners[$event])) {
            return;
        }
        
        foreach ($this->listeners[$event] as $listener) {
            call_user_func($listener['callback'], $data);
        }
    }
}

/**
 * Helper functions for working with events
 */

/**
 * Add an event listener
 * 
 * @param string $event Event name
 * @param callable $callback Function to call when event is triggered
 * @param int $priority Priority (higher numbers run first)
 * @return void
 */
function on_event($event, $callback, $priority = 10) {
    EventManager::getInstance()->addListener($event, $callback, $priority);
}

/**
 * Remove an event listener
 * 
 * @param string $event Event name
 * @param callable $callback Function to remove
 * @return bool True if listener was removed
 */
function off_event($event, $callback) {
    return EventManager::getInstance()->removeListener($event, $callback);
}

/**
 * Trigger an event
 * 
 * @param string $event Event name
 * @param mixed $data Data to pass to listeners
 * @return void
 */
function trigger_event($event, $data = null) {
    EventManager::getInstance()->trigger($event, $data);
}
?>
                    

Example: Form Processing with Events

<?php
require_once 'event_system.php';

// Component 1: Form Handler
class UserRegistrationForm {
    public function process($formData) {
        // Basic validation
        if (empty($formData['email']) || empty($formData['password'])) {
            return false;
        }
        
        // Trigger form.processed event with the form data
        trigger_event('user.register.submitted', $formData);
        
        return true;
    }
}

// Component 2: Email Validator
class EmailValidator {
    public function __construct() {
        // Register to listen for the form.processed event
        on_event('user.register.submitted', [$this, 'validateEmail']);
    }
    
    public function validateEmail($data) {
        if (!filter_var($data['email'], FILTER_VALIDATE_EMAIL)) {
            trigger_event('user.register.invalid_email', $data);
            return;
        }
        
        trigger_event('user.register.email_valid', $data);
    }
}

// Component 3: Password Validator
class PasswordValidator {
    public function __construct() {
        // Register to listen for the form.processed event
        on_event('user.register.submitted', [$this, 'validatePassword']);
    }
    
    public function validatePassword($data) {
        if (strlen($data['password']) < 8) {
            trigger_event('user.register.invalid_password', $data);
            return;
        }
        
        trigger_event('user.register.password_valid', $data);
    }
}

// Component 4: User Creator
class UserCreator {
    private $valid_email = false;
    private $valid_password = false;
    private $current_data = null;
    
    public function __construct() {
        // Register for validation events
        on_event('user.register.email_valid', [$this, 'markEmailValid']);
        on_event('user.register.password_valid', [$this, 'markPasswordValid']);
        
        // Register for invalid events to reset flags
        on_event('user.register.invalid_email', [$this, 'markEmailInvalid']);
        on_event('user.register.invalid_password', [$this, 'markPasswordInvalid']);
    }
    
    public function markEmailValid($data) {
        $this->valid_email = true;
        $this->current_data = $data;
        $this->attemptUserCreation();
    }
    
    public function markPasswordValid($data) {
        $this->valid_password = true;
        $this->current_data = $data;
        $this->attemptUserCreation();
    }
    
    public function markEmailInvalid($data) {
        $this->valid_email = false;
        trigger_event('user.register.failed', [
            'reason' => 'Invalid email address'
        ]);
    }
    
    public function markPasswordInvalid($data) {
        $this->valid_password = false;
        trigger_event('user.register.failed', [
            'reason' => 'Password too short (minimum 8 characters)'
        ]);
    }
    
    private function attemptUserCreation() {
        if ($this->valid_email && $this->valid_password && $this->current_data) {
            // All validations passed, create the user
            $userId = 123; // In a real app, this would insert to database and get ID
            
            trigger_event('user.register.success', [
                'user_id' => $userId,
                'email' => $this->current_data['email']
            ]);
            
            // Reset flags
            $this->valid_email = false;
            $this->valid_password = false;
            $this->current_data = null;
        }
    }
}

// Component 5: Email Notifier
class EmailNotifier {
    public function __construct() {
        on_event('user.register.success', [$this, 'sendWelcomeEmail']);
    }
    
    public function sendWelcomeEmail($data) {
        // In a real app, this would send an actual email
        echo "Sending welcome email to: " . htmlspecialchars($data['email']) . "
";
    }
}

// Initialize components
$form = new UserRegistrationForm();
$emailValidator = new EmailValidator();
$passwordValidator = new PasswordValidator();
$userCreator = new UserCreator();
$emailNotifier = new EmailNotifier();

// Listen for success and failure events for UI feedback
on_event('user.register.success', function($data) {
    echo "
Registration successful! User ID: " . $data['user_id'] . "
";
});

on_event('user.register.failed', function($data) {
    echo "
Registration failed: " . $data['reason'] . "
";
});

// Process a form submission
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $form->process($_POST);
}
?>

<!-- Registration Form -->
<form method="post">
    <div>
        <label for="email">Email:</label>
        <input type="email" id="email" name="email" required>
    </div>
    <div>
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required>
    </div>
    <button type="submit">Register</button>
</form>
                    

Example: WordPress Hook-Based Component

// File: social_share_component.php
<?php
/**
 * Social Share Component
 * 
 * A reusable component for adding social sharing to WordPress content
 */
class SocialShareComponent {
    /**
     * Default settings
     * 
     * @var array
     */
    private $defaults = [
        'networks' => ['facebook', 'twitter', 'linkedin'],
        'position' => 'after',
        'show_count' => true,
        'custom_class' => '',
    ];
    
    /**
     * Current settings
     * 
     * @var array
     */
    private $settings;
    
    /**
     * Initialize the component
     * 
     * @param array $settings Custom settings
     */
    public function __construct($settings = []) {
        // Merge with defaults
        $this->settings = wp_parse_args($settings, $this->defaults);
        
        // Register hooks
        add_filter('the_content', [$this, 'addShareButtons']);
        add_action('wp_enqueue_scripts', [$this, 'enqueueAssets']);
    }
    
    /**
     * Add share buttons to content
     * 
     * @param string $content The post content
     * @return string Modified content
     */
    public function addShareButtons($content) {
        // Only on single posts/pages
        if (!is_singular()) {
            return $content;
        }
        
        $buttons = $this->renderButtons();
        
        // Add buttons based on position setting
        if ($this->settings['position'] === 'before') {
            return $buttons . $content;
        } elseif ($this->settings['position'] === 'both') {
            return $buttons . $content . $buttons;
        } else {
            return $content . $buttons;
        }
    }
    
    /**
     * Enqueue required CSS and JavaScript
     */
    public function enqueueAssets() {
        wp_enqueue_style(
            'social-share-component',
            plugin_dir_url(__FILE__) . 'css/social-share.css',
            [],
            '1.0.0'
        );
        
        wp_enqueue_script(
            'social-share-component',
            plugin_dir_url(__FILE__) . 'js/social-share.js',
            ['jquery'],
            '1.0.0',
            true
        );
    }
    
    /**
     * Render the share buttons HTML
     * 
     * @return string The buttons HTML
     */
    private function renderButtons() {
        $post_url = urlencode(get_permalink());
        $post_title = urlencode(get_the_title());
        
        $html = '<div class="social-share-component ' . esc_attr($this->settings['custom_class']) . '">';
        $html .= '<h4>Share this post:</h4>';
        $html .= '<ul class="share-buttons">';
        
        foreach ($this->settings['networks'] as $network) {
            switch ($network) {
                case 'facebook':
                    $html .= '<li class="facebook">';
                    $html .= '<a href="https://www.facebook.com/sharer/sharer.php?u=' . $post_url . '" target="_blank">';
                    $html .= '<span class="icon">Facebook</span>';
                    
                    if ($this->settings['show_count']) {
                        $html .= '<span class="count">0</span>';
                    }
                    
                    $html .= '</a></li>';
                    break;
                    
                case 'twitter':
                    $html .= '<li class="twitter">';
                    $html .= '<a href="https://twitter.com/intent/tweet?url=' . $post_url . '&text=' . $post_title . '" target="_blank">';
                    $html .= '<span class="icon">Twitter</span>';
                    
                    if ($this->settings['show_count']) {
                        $html .= '<span class="count">0</span>';
                    }
                    
                    $html .= '</a></li>';
                    break;
                    
                case 'linkedin':
                    $html .= '<li class="linkedin">';
                    $html .= '<a href="https://www.linkedin.com/shareArticle?mini=true&url=' . $post_url . '&title=' . $post_title . '" target="_blank">';
                    $html .= '<span class="icon">LinkedIn</span>';
                    
                    if ($this->settings['show_count']) {
                        $html .= '<span class="count">0</span>';
                    }
                    
                    $html .= '</a></li>';
                    break;
            }
        }
        
        $html .= '</ul>';
        $html .= '</div>';
        
        return $html;
        
?>